It has come to our attention that there are questions about the network's holdings. Specifically, a cluster of connected wallets inside our own ecosystem, the kind of bundle that shows up on a tool like Bubble Maps. We want to be direct about it, because the answer is the opposite of what a cluster usually means.
We are building a decentralized network of value for the people who participate in it. That network has a real monetary value attached to it, denominated in CIRC, and we are tracking it. The CIRC that looks concentrated today is not a position waiting to be sold. It is the working capital of a network being stood up. The largest part, roughly 80 million CIRC, is staged to become the stakes for our node clients and our node. The rest is the machinery we have funded to get everything running and tested: the treasury that collects x402 payments, the escrow that holds task rewards, the distributor that pays out stakers, and the agents we have topped up to keep the system transacting (about 5M sits in their wallets today). Beyond those operating wallets we hold reserves earmarked for specific jobs still ahead: our own validator, marketing, a developer hackathon, and a block locked on-chain via Streamflow, each one covered below. All of it traces back to the same deployer and moves between wallets we control, which is exactly why it renders as one connected bundle. As these roles open to the public, that concentration converts into bonded network stake, and our share of it disperses into the community by design.
This article maps the whole thing. Every layer that holds CIRC, why it holds it, where the value flows, and what the picture looks like when the network scales out to many nodes, many clients, and many agents.
The Value Map
CIRC is held at every layer of the stack, for a different reason at each one. Here is the full vertical view, top to bottom:
┌──────────────────────────────────────────────┐
SOURCE │ PUMP.FUN DEV REWARDS │
│ protocol fees accrue to the dev position │
└───────────────────────┬──────────────────────┘
│ claimed by
┌───────────────────────▼──────────────────────┐
HOLDS │ CIRCUIT LP AGENT · Dev Wallet │
CIRC+SOL │ claims fees → splits 50 / 50 │
│ 50% market-buys CIRC │
│ 50% kept as SOL │
└───────────────────────┬──────────────────────┘
│ pair + lock
┌───────────────────────▼──────────────────────┐
HOLDS │ LOCKED LIQUIDITY POOL │
CIRC+SOL │ CIRC + SOL, liquidity locked · accumulates │
│ permanently, never withdrawn │
└──────────────────────────────────────────────┘
══════ REVENUE FLOWS DOWN · CIRC REDISTRIBUTES BACK OUT ══════
┌──────────────────────────────────────────────┐ ┌────────────────────┐
HOLDS │ AGENT SWARM (10 in-house + deployed) │ │ TASK ESCROW │
CIRC │ working CIRC to pay x402 for data + │◄───►│ separate keypair; │
│ inference; post / accept CIRC-paid tasks │ task│ holds only pending│
└───────────────────────┬──────────────────────┘rewards task rewards in │
│ x402 payments in/out│ trust → released │
▼ │ on delivery, │
┌──────────────────────────────────────────────┐ │ refunded on cancel│
HOLDS │ TREASURY (the x402 payment receiver) │ └────────────────────┘
CIRC │ accumulates revenue → distributor pays it │
│ out to stakers every 30 minutes │
└───────────────────────┬──────────────────────┘
│ distributor · 30-min payout
┌───────────────────────▼──────────────────────┐
STAKES │ NODE CLIENTS (6 live → 12) │
CIRC │ staked CIRC + registered wallet → payout │
│ list. Holds your address, never your keys. │
└───────────────────────┬──────────────────────┘
│ sync · serve · register
┌───────────────────────▼──────────────────────┐
HOLDS │ CIRCUIT NODE (the canonical hub) │
CIRC │ node holds CIRC to run · opens the internal │
│ x402 passthrough for local systems │
└───────────────────────┬──────────────────────┘
│ fed by
┌───────────────────────▼──────────────────────┐
BASE │ INDEXER · GEYSER · VALIDATOR │
│ the live on-chain data the network sells │
└──────────────────────────────────────────────┘
┌──────────────────────────────────────────────┐
STAGING │ TEAM STAGING WALLETS (~80M CIRC) │
~80M │ ~60M → our 12 client stakes · ~20M → node │
│ bonded into the network when staking is live│
│ (the heaviest part of the Bubble Maps bundle)│
└──────────────────────────────────────────────┘
Data flows up the stack. CIRC flows down as payment, then back out as distribution. Every box is a place value is held, and every one holds it for a specific, non-discretionary reason. Let's walk them.
The Source: Circuit LP Agent and the Dev Wallet
At the top of the stack is the Circuit LP Agent. It controls the dev wallet, and it runs on a fixed schedule with no human in the loop.
On every cycle it does four things:
- Checks for and claims the accrued pump.fun dev rewards.
- Splits the proceeds 50 / 50.
- Market-buys CIRC with one half, on-chain at the market price.
- Pairs that CIRC with the other half (SOL) and deposits it into the liquidity pool.
The dev wallet therefore holds CIRC and SOL only in transit. It is a router, not a vault. Its job is to convert protocol revenue into deeper, permanent liquidity, and it is the only wallet in the system that creates organic CIRC demand: every cycle, fees that would otherwise sit idle become a market buy.
The LP Agent runs on a deterministic timer, so the conversion happens whether or not anyone is watching. It is the most upstream loop in the network, and it points in one direction only: toward the pool.
The Pool: Locked Liquidity That Only Grows
The liquidity the LP Agent deposits is locked. It is not a position we manage, rebalance, or pull. CIRC and SOL go in; nothing comes out.
This is a deliberate, permanent holding. Locked liquidity does two things at once:
- It maintains a tradable market for CIRC that deepens automatically as pump.fun fees accrue. The more the network is used, the deeper the floor.
- It removes any question of the team pulling liquidity. The CIRC in the pool is paired, locked, and accumulating. It is held for the market, not against it.
Every cycle of the LP Agent makes this pool larger.
The Swarm: Self-Funding CIRC for the Agents
Below the funding layer sits the agent swarm. Each agent has its own wallet, and each wallet holds CIRC for one operational reason: to pay for x402 calls.
Every time an agent reads market data or requests inference, it pays in CIRC over the x402 protocol, a single HTTP round trip that settles a fractional-cent Token-2022 transfer on-chain. No subscriptions, no API keys. The CIRC an agent holds is its fuel.
The mechanism that changes the dynamic: the agents refuel themselves. Each agent automatically takes 25% of its trading profit and market-buys CIRC with it, on-chain, inside the trade executor, with no human in the loop. That CIRC pays for the data and inference that make it profitable, so a winning agent keeps turning a slice of its profit into CIRC demand and more capability. The loop closes on itself.
Today there are ten in-house agents, plus other deployed agents on the network. The stack is live, and a large part of bringing it up has been loading and testing real data and token flows across every end of it: data flowing up from the indexer, CIRC flowing back down through x402, the treasury, and the payout path. The agents trade on their own. We periodically fund them to keep that flow running steadily, so we can exercise the full loop end to end and watch how CIRC actually moves through the system before staking opens.
That funding is a testing input, not a permanent subsidy. The agents already refuel themselves on 25% of their profit; the top-ups simply sustain volume while we test the economics and build out other layers in parallel. As the self-funding loop carries more of the weight, the top-ups taper off. The working CIRC comes from the agents' own market buys, and every winning trade adds organic CIRC demand to the market.
An agent's CIRC is not a holding; it is fuel it earns, buys, and spends as it works.
What You're Seeing on Bubble Maps
Let's be straight about the cluster. Open a tool like Bubble Maps and you will see a group of connected wallets, and yes, that is us. Essentially everything we have done on-chain shows up there: the treasury, the escrow, the distributor, the staging wallets, the agent wallets, the dev/LP wallet. They render as one connected bundle because they share a common origin, the deployer, and because we move CIRC between them as we operate the network.
So is it a cluster? Literally, yes. But not in the sense the word is usually meant. It is not a coordinated float lined up to dump on the market. It is the on-chain footprint of a network being operated, tested, and distributed, every wallet in the bundle doing a specific job in the stack we have been walking through. The next sections name what each part of that bundle is.
Start with the two accounts that move the most and hold the least. They are distinct network wallets, with different jobs and different keypairs.
The Treasury: Where x402 Revenue Lands
When agents pay x402, that CIRC does not teleport to stakers. It lands in the treasury, the network's x402 payment receiver. The treasury accumulates revenue between payout cycles, and a distributor pays it out every thirty minutes to everyone on the staking list. The treasury is the larger of these operational accounts, but it is still modest: it holds only what the network has actually earned through x402 so far. It is revenue in transit, one of the lighter wallets in the bundle.
AGENTS ──x402 CIRC──► TREASURY ──distributor·30 min──► STAKERS
(pay) (accumulates (node clients
revenue) + nodes)
Revenue comes in continuously; the distributor pushes it back out every thirty minutes and holds little itself.
The Task Escrow: Bounties Held in Trust
The second account is a separate keypair with a completely different purpose, and it sits outside the revenue path. When one agent hires another through the task market by posting a job with a CIRC reward, that reward is locked in the task escrow until the work settles: released to the worker on delivery, refunded to the poster on cancellation. Its balance should equal exactly the sum of open, unsettled rewards, nothing more. It is funds in trust between a poster and a worker, not revenue the team controls, and it is kept on its own keypair so a problem with one account can never reach the other.
Both will show on the holdings dashboard: the treasury's balance tracks revenue earned, the escrow's tracks task activity in flight.
Node Clients: Staked CIRC With Skin in the Game
Beneath the treasury are the node clients, and this is where the public begins to hold the network.
First, what they are for. A node client is a working piece of the network's distributed layer, not just a wallet that earns. Right now each one hosts a shard of a decentralized LLM: a slice of an inference engine that the network sells access to over x402, spread across many machines instead of running on one. Next they become connection points into the dRPC service, the network's decentralized RPC. So a node client does real work for the network, and the CIRC stake is the ticket to doing it and earning from it.
We run six today, with six more being deployed for a total of twelve. On release, anyone will be able to run one. The mechanism is staking:
- A user stakes CIRC and connects their wallet to a node client.
- That registers their address with the payout system.
- On every distribution cycle, if the stake is still in place, the address is included in the batch.
The proposed minimum stake is still being finalized, but we are leaning toward 5 million CIRC per client. Across twelve clients that is roughly 60 million CIRC.
Here is the part that is easy to misread. That 60M is held by us today, sitting in the staging wallets because staking isn't live yet. When it goes live, we stake it into our own twelve clients. That is not pulling value out; it is the opposite: ≈60M moves out of a liquid reserve and locks into the network as bonded stake, turning a balance-sheet number into real staked depth on the layer it secures.
On release, anyone can run a client and stake their own CIRC alongside ours. As they do, the staked base grows past our 60M and our share of it shrinks, while the CIRC we stake stays bonded underneath the newcomers.
Two design choices matter here:
- The node client never holds your private key. It holds a record of your address, which it adds to the payout list each cycle while you remain staked. Custody stays with you; the client only needs to know where to send your share.
- Staking is the skin-in-the-game gate. Requiring a real CIRC stake is what makes the payout list Sybil-resistant. You cannot spin up a thousand empty clients to farm distribution. Stake is the cost of being on the list, and it is locked while you earn.
The Circuit Node: The Hub, and the x402 Passthrough
At the center of everything is the circuit node, the canonical hub. It connects to the geyser and indexer, turning raw validator events into the structured data the whole network reads, and it serves that data out through eighty-plus endpoints.
Running a node is the highest-commitment role in the system, and it holds CIRC accordingly. The current planned requirement is 20 million CIRC held by the node. Like the client stakes, that 20M is ours today and gets bonded into our node when staking goes live: another block of reserve CIRC locked into running infrastructure. There is also a hardware barrier, since a node does heavy work (RPC aggregation, shard routing, data serving) and needs real machines to do it.
Holding the node requirement unlocks a concrete privilege: the internal x402 passthrough. Any agent or information system running locally alongside the node is x402-exempt. It reads the network's data without paying per call, because the operator has already posted 20M CIRC and the hardware to serve it. The node is also added to the distribution list, earning from the treasury payout like the clients do.
So the node's CIRC is held for two reasons at once: it is the access credential that turns on free local data, and it is the bond that says this operator is a real, committed piece of infrastructure. The high bar is the point. The hub of the network should be expensive to run and expensive to fake.
The Base: Indexer, Geyser, Validator
Underneath the hub is the infrastructure that produces the data in the first place: the indexer, the geyser plugin that runs inside the validator, and eventually our own validator. These layers don't hold CIRC. They are the reason CIRC has utility, producing the live on-chain data that every layer above pays to consume.
When this base is fully live, the network's hot-path data costs drop to the cost of running our own hardware, and the margin at every layer above improves. The value held in CIRC at the upper layers is, ultimately, a claim on the output of this base.
The Staging Wallets and the Reserves
The treasury and escrow are light. The weight of the bundle, the part that actually reads as a large concentration, is our staging wallets: CIRC we have acquired and are pre-positioning to stand up the next phases of the network. It comes to roughly 80 million CIRC, and it is earmarked for exactly two things. About 60M is the stake for our twelve node clients (≈5M each) and about 20M is the stake to run our node. Both have to be in place, in the right wallets, before those layers can go live.
It also moves between wallets as we sort it into the parcels each role needs: roughly 5M per client, 20M for the node. On-chain that reads as wallets passing CIRC around, which is what staging looks like, not a float headed for an exit.
The tell is the direction of travel. A position built to be sold flows out to the market; this CIRC flows in, into the locked LP, the client stakes, and the node bond. When staking opens it gets staked, not sold, and as the public stakes alongside us our share of the bonded total falls while the CIRC we staked stays put.
Separate from the staging, we have funded the swarm itself. Over the course of testing, roughly 17 million CIRC has gone into the agents through top-ups. Most of it, about 12 million, has already passed through them paying x402 as they transact. The remaining 5 million sits in the agent wallets today, and that 5M is the only part still showing as an agent holding. It is the most transitional piece of the bundle: as the agents self-fund on their 25%-of-profit buys, the top-ups stop.
The reserves still ahead
Beyond the operating wallets and the staging, we hold four reserves set aside for the parts of the network that are still coming. None of them is a position waiting to be sold, and all of them will be labeled on the holdings dashboard.
The validator fund, about 30M. The base of the stack is meant to be our own Solana validator, the piece that lets the network stop paying outside providers for its data. Standing one up is a real capital cost, so we have set roughly 30M CIRC aside against it. The infrastructure gets funded from the network's own asset rather than by selling it.
Marketing and the hackathon prize, about 19M and 15M. Growth is a budgeted line, not an afterthought. Roughly 19M is reserved for marketing (partnerships, campaigns, reach) and about 15M is earmarked as a hackathon prize pool to bring developers onto the stack. Both are CIRC pointed at expanding usage, which is what creates demand for the token.
The Streamflow lock, about 10M. Roughly 10M CIRC is time-locked on Streamflow, an on-chain vesting contract anyone can verify. Locked tokens cannot be sold while they vest. It is a block of our own holdings under a public, enforceable lock, the same posture as the LP.
Every bucket above is CIRC with a job. When the holdings dashboard goes live, each one will be on it with its balance and purpose labeled, so you can verify the full map instead of taking our word for it.
The Flow, End to End
Put the holdings in motion and the economy is a single loop:
pump.fun fees
│ 50% market-buy
▼
CIRC ──► LOCKED LP (permanent, deepening)
▲
│ buy pressure
─────┼──────────────────────────────────────────────
│
AGENTS hold CIRC ──x402──► TREASURY ──30 min──► STAKERS
▲ ▲ │
│ └─ 25% of profit ──► market-buy CIRC (self-refuel)
│ re-stake / hold │
└──────────────────────────────────────────┘
│
└─ agent-to-agent task reward ──► TASK ESCROW ──► worker on delivery
(held in trust) (or refund on cancel)
TEAM STAGING (~80M) ──seeds──► client stakes · node
(shrinks as the public stakes in)
Revenue enters from network usage. Half of all protocol fees become permanent locked liquidity. Agents fund their own CIRC by market-buying with 25% of their profit, then spend it on data and inference; that spend accumulates in the treasury, and the distributor pays it out to everyone staked, every thirty minutes. Separately, when agents hire each other through the task market, the reward sits in the task escrow until the job settles. The team's ≈80M staging gets bonded into client stakes and the node when staking goes live; the community then stakes alongside it, and the team's share of the total shrinks over time.
Extrapolating Forward: A Network of Many
Everything above is the network at its starting size: ten agents, six clients going to twelve, one hub. The architecture is built to scale to orders of magnitude more, and the holdings picture transforms when it does.
FROM (today) TO (at scale)
─────────────────────── ───────────────────────────
10 agents thousands of agents
6 → 12 node clients a larger staked-client base
1 canonical hub a mesh of independent nodes
team seeds most stakes community holds most stakes
payout → 12 addresses payout → thousands of addresses
Trace each layer forward.
Agents become a continuous revenue firehose. Ten agents paying x402 is a trickle. Thousands of agents (trading, optimizing yield, monitoring launches, watching wallets) paying for data and inference around the clock turns the treasury into a steadily filling pool. More agents means more x402 volume, which means a larger batch to distribute every thirty minutes.
Node clients become a community-held base. Every staked client locks CIRC out of circulation, so the number of clients is bounded by how much of the supply is staked and by the per-client minimum. That minimum is a tunable parameter set against the token's value, not a fixed figure, so the size of the client layer scales with how staking is calibrated rather than being a number we can pin today. What has no such bound is the participation behind the clients: agents run into the thousands, and because many wallets can stake and earn through the network's clients, the payout list climbs from a handful of addresses into the thousands, each one earning a share of the thirty-minute distribution.
Nodes multiply and decentralize the hub. Today one canonical node anchors the network. As operators with hardware and 20M CIRC come online, the hub role spreads across many independent nodes, each bonded, each serving shards, each on the payout list, each opening a local x402 passthrough for the systems around it. The center stops being a single point and becomes a mesh.
The team's share falls, on purpose. This is the resolution to the cluster question. The concentration that exists today is the seed. As the public stakes clients, runs nodes, and deploys agents, team-held CIRC moves into locked, bonded, distributed roles while the community's stake grows around it. The team's percentage of staked supply declines every time someone new joins. A healthy version of this network is one where the team is a small fraction of a large, broadly-held staked base.
Demand stays structural. None of this depends on speculation. To participate you need CIRC: to stake a client, to run a node, to fuel an agent. To consume the network you spend CIRC over x402. Every new participant is a new, software-driven source of demand, and half of every protocol fee keeps flowing into locked liquidity underneath it all.
The end state is a network where most CIRC is held by its users, staked into clients and nodes, working inside agents, locked in the pool, and where a fixed share of every dollar of usage is redistributed, on a thirty-minute clock, to the people holding it up. The value we are tracking today is the first measurement of that system. The cluster is the starting line, not the destination.
In Short
- CIRC is held at every layer, for a reason at each one: routed through the dev wallet, locked in the LP, bought and spent as fuel by self-funding agents, collected in the treasury, held in trust in the task escrow, bonded as client stake, and posted as the node requirement.
- Agents fund themselves. Each one market-buys CIRC with 25% of its trading profit to pay for its own data and inference. The team top-ups are a temporary testing input that keeps real flow moving through the stack, and they taper off as the agents' own buy pressure takes over.
- The bundle on Bubble Maps is us, and it is operational. Treasury, escrow, distributor, agent wallets, the dev/LP wallet, and the staging wallets all trace to the deployer, so a clustering tool draws them as one group. It is a cluster in the literal sense, the footprint of a network being operated, tested, and distributed, not a coordinated float.
- The weight is staging that converts to stake, not sales. The ≈80M (≈60M for our twelve client stakes, ≈20M for our node) is held by us now and gets bonded into our own clients and node when staking goes live. That transfers ≈80M of value in as committed stake; our share shrinks as the public stakes alongside us.
- The reserves each have a defined job: ≈30M toward our own validator, ≈19M for marketing, ≈15M for a developer hackathon prize, and ≈10M publicly locked on Streamflow. None of it is a position waiting to be sold.
- At scale, the holdings invert. Most CIRC ends up staked and held by independent operators, with the team a shrinking share of a much larger base.
When staking goes live, every figure described here lands on the dashboard, so you can verify the map for yourself. Until then, if you have questions, ask. We would rather over-explain this than leave it to guesswork.
A Note on the Largest Holder
One aside, since it comes up when people scan the holder chart: the largest single CIRC holder is not the team. It is a community member who came in through the swarm and is using their own CIRC to build agents for the network. Any line a clustering tool draws between that wallet and ours runs through swarm activity, the agents and signals they contribute, not through our deployer or our wallets. The biggest position in CIRC already belongs to an independent participant building on the network, which is exactly the direction the whole system is meant to go.
Circuit LLM is experimental software. Autonomous agents transact real assets on Solana mainnet. Token requirements and staking parameters described here are planned values, some still pending final approval, and may change before release. Nothing here is financial advice.