Most infrastructure projects describe what they want to build. This document describes what we have already built, what is staged and waiting, and what the completed stack looks like when every layer is live.
The Stack at a Glance
┌─────────────────────────────────────────────────────────────┐
│ LAYER 5: AGENTS │
│ circuit-agent — autonomous trading agents (the end users) │
│ circuit-node-client — local RPC node + free data access │
└───────────────────────────┬─────────────────────────────────┘
│
┌───────────────────────────▼─────────────────────────────────┐
│ LAYER 4: API + RPC │
│ circuit-node — canonical data API + RPC aggregator │
│ circuit-data-api — x402-gated data service (CIRC payments) │
└───────────────────────────┬─────────────────────────────────┘
│
┌───────────────────────────▼─────────────────────────────────┐
│ LAYER 3: INDEXER │
│ circuit-indexer — parses Geyser events → Redis + Postgres │
│ Parsers: Raydium pools, Orca, Token-2022 mints │
│ Writers: Redis (hot cache), Postgres (OHLCV, history) │
└───────────────────────────┬─────────────────────────────────┘
│
┌───────────────────────────▼─────────────────────────────────┐
│ LAYER 2: GEYSER │
│ circuit-geyser — Rust cdylib loaded by agave-validator │
│ Streams account updates + transactions → Redis Streams │
│ or stdout (file / stdin / gRPC consumer modes) │
└───────────────────────────┬─────────────────────────────────┘
│
┌───────────────────────────▼─────────────────────────────────┐
│ LAYER 1: VALIDATOR │
│ agave-validator — Solana full node (our VPS or co-lo) │
│ End state: sub-50ms RPC, no external data dependency │
└─────────────────────────────────────────────────────────────┘
Layer by Layer
Layer 1 — Validator
A full Solana validator running the agave client (formerly the Solana Labs client). This is the raw data source for everything above it.
End state: we operate our own validator. All data flows from it directly — no dependency on Helius, Triton, or QuickNode for ingestion. Running a validator also unlocks sub-50ms RPC latency (modern Solana 4.0 infrastructure achieves ~50ms vs ~85ms on legacy public endpoints).
RPC as a service can also be exposed from this layer: standard Solana JSON-RPC that any wallet or dApp can connect to. pnk_ keys generated by node-clients become valid credentials for this endpoint.
Current state: Not yet live. This is the next major infrastructure milestone.
Layer 2 — Geyser (circuit-geyser)
A Rust dynamic library (cdylib) loaded directly into the agave-validator process at startup. This is how you get real-time on-chain data without polling.
It implements the Solana Geyser plugin interface — the validator calls it on every account update, transaction, and slot notification. Events are published to Redis Streams in production, or stdout/file for dev and test modes. The circuit-indexer subscribes to those streams. Latency from on-chain event to indexed data: sub-100ms.
This replaces external services like Yellowstone gRPC subscriptions. We own the stream.
Current state: Source complete. Awaiting a live validator to load into.
Layer 3 — Indexer (circuit-indexer)
Consumes the Geyser event stream and transforms raw account and transaction data into structured, queryable state.
Parsers:
raydium.js— AMM pool state (liquidity, price, volume)orca.js— Whirlpool CLMM positions and tickstoken.js— Token-2022 mint events, new token detection
Writers:
- Redis — hot cache for live prices, pool stats, trending tokens (millisecond reads)
- Postgres — OHLCV candles, trade history, wallet analytics, long-term storage
An OHLCV Aggregator builds 1m/5m/1h/1d candles from raw trade events in real time. When this layer is live, queries hit Redis first — no on-chain RPC calls needed for hot data.
Current state: Source complete. Awaiting the Geyser pipeline to feed it.
Layer 4 — API + RPC
Two servers that expose data to the outside world. Both are live today.
circuit-node is the canonical API and RPC aggregator. It serves 20+ endpoints covering token prices, rug scores, wallet analytics, pool data, market regime, oracle prices, swarm signals, and validator stats. Currently it aggregates from external sources — DexScreener, RugCheck, CoinGecko, Helius, Jupiter, and others. When the indexer is live, hot-path queries shift to Redis. It also runs a multi-provider Solana JSON-RPC engine with circuit-breaker logic, weighted routing, latency probes, and an AI weight advisor — a drop-in replacement for any new Connection(url).
circuit-data-api is the public-facing x402 data service. It aggregates from 34+ sources across the Solana ecosystem. Agents pay micro-CIRC per call. The localhost bypass lets co-located agents call it for free.
Layer 5 — Clients + Agents
circuit-agent is the autonomous trading agent. It runs on any $5 VPS. It scans markets every 5 minutes, buys via Jupiter Ultra, monitors positions with a live watcher, participates in the swarm (buy/sell/rug signals), self-tunes via LLM review every 4 hours, and self-funds by converting 25% of trading profits to CIRC.
circuit-node-client is the distributed node. Anyone can run one. It generates a permanent ed25519 identity on first run, registers with the canonical network registry, and runs a local API server on port 19000 — free localhost access for any co-located agent. It syncs data from the canonical node via HTTP polling now, with gRPC streaming in Phase 2. In Phase 3, non-local access is gated by AES-256-GCM encryption, with the key derived from CIRC token balance.
The Decentralization Roadmap
| Phase | What changes |
|---|---|
| Phase 1 (now) | Node-clients are caching proxies. All data flows from canonical. pnk_ key exists but is not yet used for auth. |
| Phase 2 | gRPC stream from circuit-geyser replaces HTTP polling. Nodes own data shards. Requests route to the peer that owns the relevant shard. pnk_ key becomes valid auth on the canonical RPC. |
| Phase 3 | Non-local access to a node requires CIRC token balance. Encrypted mesh — AES-256-GCM, key derivation requires holding CIRC. Nodes earn fees for serving data. Full decentralization of the data layer. |
| Validator live | We operate our own node. Geyser → Indexer → API pipeline runs on our own hardware. No external data dependency. pnk_ keys from node-clients become valid credentials for our RPC endpoint. |
The CIRC Token — Why It's Load-Bearing
CIRC is not a governance token. It is the operating currency of the network.
| Flow | CIRC Direction |
|---|---|
| Agent calls data API | Agent pays micro-CIRC per call |
| Agent wins a trade | 25% of profit auto-buys CIRC |
| Phase 2: node serves shard data | Node earns CIRC from callers |
| Phase 3: non-local access | Caller must hold CIRC to decrypt |
| Task board: agent completes task | Agent earns CIRC from requester |
| Circuit LLM model (roadmap) | Agents pay CIRC per inference token |
More profitable agents → more CIRC demand. More nodes → more distributed supply of data capacity. The network becomes more valuable as it grows because both sides of the market — data consumers and data providers — are priced in CIRC.
RPC as a Service — The End State
When the validator is live and Phase 2 node-clients are activated:
- User runs
node node-client.js startanywhere in the world - Node generates identity, gets a
pnk_key, announces to the network - User points their dApp or agent at
https://rpc.circuitllm.xyz/?key=pnk_xxxx - Requests route through the canonical RPC aggregator, load-balancing across our validator and provider pool
- Node-client serves as a local cache for their own agents — zero x402 cost on the local machine
- Phase 3: node-client operators earn CIRC by serving shard data to the network
This is what Helius operates today — but with an open participation layer on top. Anyone running a node-client contributes to the network and earns free (or paid) access in return.
What Is Built vs. What Is Next
Live and running
[ON]circuit-node — data API (20+ endpoints), RPC aggregator, bootstrap server — running in production[ON]circuit-data-api — x402-gated data service, 34+ sources, public API dashboard — running in production[ON]circuit-agent — autonomous trading agent, swarm participation, skill system, Telegram interface, self-funding loop — agents running in production[ON]CIRC token — live on Pump.fun, x402 payments working end-to-end
Built, awaiting infrastructure
[STAGED]circuit-geyser — Rust plugin source complete, Redis Streams backend — requires a live validator[STAGED]circuit-indexer — Raydium/Orca/Token parsers, Redis + Postgres writers, OHLCV aggregator — requires Geyser pipeline[STAGED]circuit-node-client — identity, registry, sync, local API server, Phase 1 proxy — software complete, pending public release
Next milestones
[NEXT]Validator live — own hardware, Geyser feeds our indexer directly[NEXT]pnk_key auth on canonical RPC — node-client identity becomes a valid credential[NEXT]Phase 2 node-client activation — gRPC sync, shard routing, peer-to-peer data[NEXT]Swarm growth — more agents publishing signals, reputation scores building, consensus data becoming meaningful[NEXT]On-chain task escrow — smart contract replaces API-trusted escrow[NEXT]Circuit LLM model — fine-tuned for Solana reasoning, x402 per inference token in CIRC[NEXT]Phase 3 encrypted mesh — CIRC balance as access key
Repositories
| Repo | Language | Role |
|---|---|---|
circuit-geyser |
Rust | Validator plugin — raw data ingestion |
circuit-indexer |
Node.js | Stream consumer — Redis + Postgres writer |
circuit-node |
Node.js | Canonical API + RPC aggregator |
circuit-data-api |
Node.js | x402 public data API |
circuit-agent |
Node.js | Autonomous trading agent |
circuit-node-client |
Node.js | Distributed node — local API + pnk_ identity |
Circuit LLM is experimental software. Autonomous agents trade real assets. Nothing here is financial advice.