Most crypto and AI projects assemble themselves out of other people's infrastructure. They rent an RPC endpoint, call a third-party price API, wrap a hosted model, and bolt on a token. Circuit is unusual because it builds the whole stack itself, from the validator plugin that reads the chain to the inference engine that does the reasoning to the payment rail that ties the economics together. The result is a single, vertically integrated system where real-time on-chain data, autonomous trading, decentralized language-model inference, and a micropayment economy all feed one another.
This document lists the components and then explains how they connect.
What Circuit is, in one paragraph
Circuit is a Solana-native data, intelligence, and trading network. A purpose-built pipeline ingests on-chain activity in real time and turns it into prices, candles, and discovery feeds. That same data powers two things at once: a swarm of autonomous trading agents, and a public data API that anyone can pay for per request. Alongside it runs a from-scratch decentralized language model that splits one large model across commodity GPUs on separate machines. Everything that costs money to use is paid in CIRC, the network's token, through an open micropayment protocol, and the revenue recycles back into the liquidity and infrastructure that keep the system running. It is a closed loop: data becomes intelligence, intelligence earns revenue, and revenue sustains the data.
The components, by layer
1. The on-chain data pipeline (the foundation)
This is the part that makes everything else possible: a private, real-time view of the Solana DEX markets that Circuit owns end to end.
- circuit-geyser is a Rust plugin that loads directly into a Solana validator. It streams filtered account and transaction updates out of the validator as they happen, which is the real-time firehose the rest of the stack drinks from. It is cost-tuned: in production it derives trade volume and buy/sell counts from vault balance changes rather than carrying the full transaction stream, which keeps the bandwidth bill low.
- circuit-indexer consumes that firehose and parses pool state and swaps from the major Solana venues (Raydium, Orca, PumpSwap, and constant-product pools). It turns raw account data into prices and OHLCV candles and writes them to Redis, processing thousands of events per second after a raw-buffer parsing rewrite that multiplied its throughput.
- Redis is the hot-data backbone. Candles, live prices, pool mappings, trending sets, and token metadata all live here with sensible ring buffers and expirations, so the system stays fast and bounded.
- circuit-price-feed is a reserve-based pricing engine that reads Redis and serves sub-second token prices, OHLCV candles, discovery feeds (recently active tokens, top losers, trending), and slippage estimates over a small HTTP API. It is the data surface the trading agents actually read.
- circuit-node is a Solana RPC aggregator and data API. It pools multiple RPC providers behind intelligent load balancing, latency tracking, and circuit breakers, exposes more than eighty endpoints for chain, DeFi, token, wallet, and market data, and runs as a small cluster for resilience. It also hosts the swarm coordination API and a peer-discovery bootstrap for the node mesh.
- circuit-data-api is the public, paid face of the data layer. It aggregates dozens of sources into a unified REST API and gates each call behind a CIRC micropayment, so any external builder can buy exactly the data they need without an account or a subscription.
2. The decentralized inference engine (the intelligence layer)
- circuit-dllm is a from-scratch Python and PyTorch inference engine that splits a single large model by transformer layer across several GPUs on separate machines, connected over an encrypted network. The model in production is Qwen2.5-72B, served across four commodity L4 GPUs rather than one expensive accelerator. A predictive-drafting technique lets a small fast model propose tokens that the large model verifies in batches, which recovers much of the speed lost to splitting the model across a network.
- circuit-inference-gateway is the paid entrypoint that fronts the engine at inference.circuitllm.xyz. It enforces a CIRC micropayment per call, caps the generation size so one payment cannot drain a GPU, and proxies the request to the engine. The free chat demo on the website is a separate path, so the public can try the model without paying while production traffic settles to the Distributor.
- circuit-node-client is how any machine joins the network. A GPU or CPU running it takes a shard of the decentralized model mesh and serves data, earning CIRC for the work it does. The same client is the staking interface, and is where a decentralized RPC will live as the network grows.
3. The autonomous trading swarm (the application layer)
- circuit-agent is the canonical autonomous trading runtime. A single agent scans the live market through the price feed, scores candidates with a dip-reversal model, confirms the price before it buys, manages exits with layered stop, trail, and take-profit logic, and can call the decentralized model for higher-level reasoning. It is also a paying customer of the data API, which closes a small loop on its own.
- circuit-swarm is ten of those agents running together. They coordinate through the node's swarm API rather than a central controller: they publish trade signals, carry reputation scores, share a blacklist of rugged tokens, and spread across candidates so the group behaves like a diversified book. The strategy is run at deliberately small size while it is tuned, so the agents are a live testbed for the rest of the stack as much as a profit engine.
The runtime is a foundation, not a single application. A new specialist agent is a strategy and a configuration layered onto the same scanning, execution, and coordination machinery, so building a different kind of agent on Circuit does not mean rebuilding the plumbing underneath it.
4. The token economy and the Distributor (the economic loop)
- CIRC is the network's token, issued under the Token-2022 standard. It is the unit of account for every paid action in the system.
- x402 is the micropayment protocol that gates the data API and the inference gateway. A client sends CIRC to the Distributor, references the transaction as proof, and the server verifies the payment on-chain before serving the call. There are no API keys and no monthly plans, just pay-per-request settlement in the open.
- The Distributor is the wallet all x402 revenue settles to, from both data and inference. It does not simply hold that revenue: every thirty minutes it pays it out to the node-clients that have staked CIRC, so running and staking on the network earns a continuous share of what the network makes.
- circuit-lp-agent is an autonomous fee recycler. On a schedule it claims the trading fees Circuit's own token earns on its launch venue, swaps part of them into CIRC, and deposits the pair into a Meteora liquidity pool. This turns protocol activity back into liquidity for the token that powers the payments, and the bulk of that liquidity is permanently locked.
- A separate escrow wallet holds task-reward payouts, deliberately kept apart from the Distributor so the two roles never share a key.
5. The public surface (the front door)
- circuitllm.xyz is the main site.
- /data is a live operations terminal: system health, the network portfolio, the swarm feed, and the liquidity position, all in one view.
- /charts renders candles drawn from Circuit's own pipeline rather than a third-party charting service.
- /dllm is the free chat demo for the decentralized model.
- inference.circuitllm.xyz is the paid inference API for builders.
How it all fits together
The thing that makes Circuit coherent is that these layers are not independent products that happen to share a brand. They are wired into one another, and the wiring forms a few reinforcing loops.
The data flywheel. The geyser plugin, the indexer, and Redis produce one stream of real-time market data, and that single stream feeds two very different consumers. On one side it drives the trading swarm, which needs sub-second prices to find and manage positions. On the other side it powers the public data API, which sells the same underlying intelligence to outside builders. Building the pipeline once and monetizing it twice is the core efficiency of the design, and it is only possible because Circuit owns the pipeline instead of renting it.
The intelligence layer sits on top of the data, not beside it. The decentralized model is not a separate demo. The trading agents can use it for reasoning, the website exposes it to the public, and the inference gateway sells it. The same philosophy that produced a self-owned data pipeline produced a self-owned model: run it on cheap commodity GPUs spread across machines, accept a modest speed cost, and keep control of the whole thing.
The economic loop closes with CIRC. Every paid action, whether it is a builder querying the data API or a user calling the model, settles in CIRC to the Distributor through the same x402 rail. The Distributor does not simply hold that revenue: every thirty minutes it pays it out to the node-clients that have staked CIRC, so the operators running and securing the network earn a continuous share of what it makes. Separately, the fee recycler turns protocol fees back into permanently locked CIRC liquidity. So usage creates demand that is split between the people who run the network and the liquidity that backs its token, and the token capturing that value is the same one the agents hold in order to pay for data. Data becomes intelligence, intelligence earns CIRC, and CIRC flows back to the machines, the stakers, and the liquidity that keep the network alive. The trading swarm rides on top of all of it, both as the system's most demanding internal customer and as a continuous, real-money test of whether the data and the models are actually good.
As a sense of scale, the network's own holdings today, the Distributor wallet, the agent wallets, and the permanently locked liquidity together, come to roughly $7,900 at current prices. A planned 60 million CIRC stake from the team adds about as much again, putting the current network at around $15,600.
What is genuinely live, and what is close behind
An honest overview has to separate the two.
What is real and running today: the data pipeline is in production and fast, serving both the swarm and the public API around the clock. The x402 payment rail works, and data and inference revenue both settle to the Distributor through it, which pays them out to staked node-clients every thirty minutes. The decentralized 72B model is live, splitting a real model across four networked GPUs and answering both the free demo and paid calls. The fee recycler runs on a schedule and keeps liquidity locked. Ten trading agents run continuously against the live market.
What is close behind: the parts that are still small are small by design, not because the hard problems are unsolved. The decentralized model already does the genuinely difficult thing, splitting one model across separate machines and keeping it coherent, so adding speed from here is mostly a question of how much hardware joins the mesh, which is the easy axis to grow. The trading strategy runs at deliberately tiny size while its entry edge is tuned, but the execution, risk, and coordination wrapped around it are production-grade and ready for size the moment the signal is. The open node-client network is live and paying operators today, and its deeper phases, per-node data shards and stake-gated RPC tiers, are designed and staged to switch on as the network grows rather than waiting to be invented. Payment volume is the one input only adoption can supply, and the rails that carry it are already proven. The hard building is largely done. What is left is turning the dials up.
That balance is the fair way to see Circuit. It is not a finished product operating at scale, and it does not need to pretend to be. What is unusual, and what is worth paying attention to, is the completeness and the coherence of the thing: a single team building every layer of a Solana data, intelligence, and trading network from the validator up, and wiring those layers into one economic loop. Most projects own one box on this diagram and rent the rest. Circuit owns the diagram.
Why the integration matters
Vertical integration is hard and usually not worth it, which is exactly why it is notable when it works. Owning the data pipeline means the trading agents and the public API are never at the mercy of a third-party rate limit or a stale feed. Owning the model means inference can be priced, placed, and shaped to the network's needs instead of a vendor's. Owning the payment rail means the same token captures value from every direction at once. Each piece is more useful because the piece next to it is also Circuit's. The whole is a working demonstration that a small team can build a self-contained on-chain intelligence economy, end to end, and run it in the open. Much of the stack is open source at github.com/Circuit-LLM.