FlameWire follows the standard Bittensor subnet model of miners providing service and validators scoring performance. Key roles include:

Miners: Node operators run full archive nodes for supported chains (initially Ethereum, Sui, and Bittensor) and register their RPC endpoints with FlameWire. They deploy these nodes globally for low latency and redundancy. The subnet client software (in Python) periodically reports health metrics to the network. As GitHub explains, miners are “Multi‑Chain Node Operators” with global coverage and redundant infrastructure.

Validators: Independent nodes continuously query and validate the miners’ responses. Validators check uptime, correctness of RPC responses, and latency, assigning scores and weights to each miner. High-scoring miners earn larger rewards. This ensures performance and honesty: “Validators … assign performance-based rewards” and enforce integrity.

Subnet Owner: A special role coordinates traffic routing and access control. The owner (operator) runs the Kong API gateway that load-balances incoming requests across miners. It directs each call to the fastest healthy node (using metrics from validators) and manages API permissions. As described in the docs, the Subnet Owner “distributes API/RPC requests to optimal nodes” and handles access management.

Network and Workflow

FlameWire’s workflow is as follows (per the official docs):

Registration: Node operators register their neuron on subnet 97 (e.g. using btcli subnet register –netuid 97 –network finney). They then run the FlameWire gateway software to register RPC endpoints and begin serving requests.

Request Routing: Developers send requests to a unified endpoint (e.g. https://rpc.flamewire.io/{chain}/). All calls pass through the Kong API gateway and are load-balanced among healthy miners. Validators continuously make test RPC calls to every miner and update each miner’s weight based on response time, reliability, etc..

Billing & Credits: Each user request consumes credits (TAO or pre-paid tokens). The system supports a stake-based free-tier (users staking Alpha tokens get some free access) and pay-as-you-go billing. Collected fees are used to buy and burn Alpha tokens or add to the subnet reserve (see Tokenomics below).

Performance Evaluation: Validators score miners over each epoch. At epoch close, Bittensor’s on-chain consensus (Yuma) computes rewards: high-performing miners and their validators receive a share of emitted tokens, while lower performers risk re-registration.

Tokenomics and Incentives

FlameWire uses Bittensor’s dynamic-TAO model with its own alpha (α) token. Key points:

Alpha Token (α): Each subnet issues a special currency called its alpha token. Users acquire FlameWire α by staking base TAO into the subnet’s reserve. The price of α adjusts with supply (a Bancor-style curve of TAO in reserve vs. α outstanding).

Emissions: The FlameWire chain emits α tokens on a schedule similar to TAO. Emissions are split between the reserve (adding liquidity) and distribution to subnet participants. Stakers of TAO and α earn a share of emissions based on stake weight.

Performance Rewards: Validators evaluate miners and assign weights. The GitHub docs note: “Validators assign scores and weights to miners; Alpha token rewards are distributed based on performance”. Thus, the best miners (and their validators) earn more α each epoch.

Circular Tokenomics: User payments (in TAO) are recycled into the subnet. Fees collected from API usage are periodically swapped into α and fed to the treasury or burned, aligning demand with token supply. Overall, the model provides a stake-based free tier (some free calls for α-stakers) plus a pay-as-you-go engine, with all payments benefiting the network and its token value.

FlameWire Products and Services

FlameWire delivers several concrete offerings:

Decentralized RPC/API Gateway: A single API endpoint that transparently routes calls to the best node. (E.g. rpc.flamewire.io/ethereum for Ethereum calls.) This replaces centralized services like Infura; it’s fully open and permissionless.

Open‑Source Gateway and Validator Software: The FlameWire client code (for miners) and validator scripts are published on GitHub (organization unitone-labs) under an MIT license. Miners run the “gateway” client, and validators run the provided validator.py (managed via PM2 as shown in the docs).

Alpha Token (α): The subnet’s currency, earned by miners/validators and used by users for access. The Alpha token trades on Bittensor’s dTAO Terminal (e.g. Backprop Finance) as soon as the subnet is live. (Note: in early days liquidity may be low, as the team has cautioned.)

Developer Access and Dashboard: Documentation and onboarding are provided via a GitBook and community channels. Developers can request API keys (see FlameWire’s Discord) to access both free-tier and paid APIs. (The FlameWire website/portal offers a dashboard and key management.)

Economic Model: As noted, the economics include a free-tier for stakers and pay-per-call model. The GitHub explicitly lists “Stake-Based Free-Tier Access” and “Pay-as-you-go” under Economic Model.

Technical Architecture and Deployment

FlameWire’s architecture combines blockchain nodes, web services, and Bittensor logic:

Node Infrastructure: Miners must run full archival nodes for the supported chains (e.g. Geth for Ethereum, Mysten for Sui, and a Bittensor node) on reliable servers. These nodes are the backbone of the service, storing the entire chain history for API queries.

API Gateway: A Kong API Gateway is used to route incoming requests to miner endpoints. Kong handles load balancing and can be deployed in Docker or Kubernetes (FlameWire docs imply Kubernetes/PM2 usage).

Software Stack: The FlameWire codebase is written in Python (the GitHub shows Python at 100% of code). Miner gateway services and validator logic run in Python. The validator is managed via PM2 (a Node.js process manager) – the docs instruct installing pm2 and running validator.py under PM2. Thus validators rely on both Python and Node/PM2.

Dependencies: Installation requires standard Python libraries (per requirements.txt) and PM2. The GitHub setup uses pip install -r requirements.txt and npm install -g pm2 for validators. Developers must ensure sufficient CPU, RAM, and network for full nodes.

Deployment: The system can be run on any Linux server. Miners register via the Bittensor CLI (btcli) on the Finney network (testnet) for now. The FlameWire GitHub provides step-by-step setup for Linux environments. No on-chain smart contract is needed (FlameWire’s logic is off-chain), but Bittensor’s on-chain consensus handles reward distribution.