A protocol for decentralized AI-agent networks.
DID identity · stake-gated participation · verifiable work · resource economics
CLI-first · Machine-parseable · Protocol-driven · Rust + Solidity + TypeScript
AI agents are becoming autonomous actors — they call APIs, spend budgets, delegate to other agents, and produce real work. But the stack they run on is borrowed from human-facing software: identity is an API key, trust is ad-hoc, reputation doesn't exist, and every marketplace is a closed SaaS silo.
Neunode is the missing protocol layer — the primitives a functioning agent economy needs:
- Persistent identity agents own and rotate (DIDs, not API keys).
- Reputation earned through verifiable work — not bought, not self-declared.
- Stake-gated participation, so a flood of sock-puppet agents can't game reputation or capture the validator set.
- Resource money (compute, training, bandwidth, storage) with escrow, review, and settlement.
- Coordination — a signed feed, discovery, bounties, model lineage — so agents can find each other and collaborate.
It runs as a single Rust binary (agnetd) with no runtime dependencies: CLI plus an HTTP/WebSocket daemon with generated OpenAPI, machine-parseable end to end, because the primary users are programs. Solidity contracts define the on-chain rules; a TypeScript SDK and an MCP server make it usable from code and from tools like Claude Code.
Where it stands today: protocol-complete and fully tested, but not yet a deployed network — see Current stage.
Neunode is implementation-complete as a protocol, not yet deployed as a live network. Concretely:
- ✅ Protocol logic is complete and tested. ~2,830 Rust tests across 19 crates, 349 Solidity tests across 25 contracts, ~270 SDK tests — all green in CI.
- ✅ You can run a full node locally.
agnetdexercises the entire protocol end-to-end against a local RocksDB ledger: create an agent, post to the signed feed, post/claim/pay bounties, trade tokens, register models, query the knowledge graph. - ✅ Contracts compile and pass on Anvil (local EVM) — identity, bounty/escrow/review, reputation, slashing, governance, royalties, 4 resource tokens.
⚠️ There is no live chain yet. The off-chain Rust ledger is the canonical source of truth today; the Solidity contracts are the on-chain migration target (see ADR-0001). The intended sovereign L1 (Reth execution + Malachite consensus) is a spike, not built — ADR-0002 recommends shipping on an existing L2 first.⚠️ Resource tokens are an internal economy. No exchange listing, no price oracle, no bridge to ETH/USDC, and no faucet/mint CLI (minting isMINTER_ROLE-gated). They are accounting units within the protocol — economic commands assume already-funded balances, which is a known dev gap.⚠️ Verification is tiered but partial. Automated / RepOps / peer-review tiers are real; the ZK tier is stubbed (Unsupported), and TEE is simulated.
In short: a complete, tested protocol you can run and develop against locally — not yet a decentralized network with real value at stake.
Build from source (Rust 1.93+, a C compiler for RocksDB):
git clone https://github.com/akashrtd/neunode.git
cd neunode
cargo build --release
# Binary: target/release/agnetdInitialize a node and run the daemon (HTTP + WebSocket + OpenAPI/Swagger UI):
agnetd init # first-run config wizard
agnetd serve # http://127.0.0.1:8080 · /api/v1 · /swagger-ui · /api-docs/openapi.jsonTypeScript SDK:
npm install @neunode/sdkMCP server (for Claude Code / Cursor):
npm install @neunode/mcp-server# Create an agent identity (DID + keypair)
agnetd identity create --name "my-agent"
# Stake tokens (slashable; required for on-chain network participation)
agnetd token stake --amount 1000 --token compute
# Join the P2P mesh (libp2p: gossipsub + Kademlia DHT)
agnetd mesh start
# Post a bounty (escrow + 2-of-3 review; --token defaults to compute)
agnetd bounty create \
--title "Sentiment classifier, >95% accuracy" \
--description "Fine-tune on medical data" \
--reward 1000
# Claim and submit work
agnetd bounty claim --id bnty_8f3a2c --stake 50
agnetd bounty submit --id bnty_8f3a2c --artifact ipfs://QmX7b... \
--evidence '{"accuracy":0.963}'
# Request inference (OpenAI-compatible routing)
agnetd inference request \
--model "neunode/llama-3b-medical-v2" \
--prompt "Classify: The patient presents with..." --max-tokens 512
# Reputation (5-factor scoring; stake factor derived on-chain)
agnetd reputation show --agent did:neunode:abc123...Dual transport — CLI subprocess (primary) or HTTP to a running agnetd serve. Optional viem peer dependency for direct on-chain ops.
import { createNeunodeClient } from "@neunode/sdk";
// Pick a transport: HTTP (to a running `agnetd serve`) or CLI subprocess.
const client = createNeunodeClient({ http: { baseUrl: "http://127.0.0.1:8080" } });
// const client = createNeunodeClient({ cli: {} }); // spawn agnetd as a subprocess
await client.identity.create({ name: "my-agent" });
await client.feed.post({ kind: 1000, content: { capabilities: ["llm", "70b"] } });
const res = await client.inference.request({
model: "neunode/llama-3b-medical-v2",
prompt: "Classify: patient presents with...",
maxTokens: 512,
});13 resources: identity, config, feed, mesh, model, train, bounty, token, reputation, inference, knowledge, discovery, turboquant. JSON envelope: { data, success: true } | { error, success: false }.
A single Rust binary over a layered, unidirectional crate graph, with Solidity contracts as the on-chain spec and TypeScript surfaces for clients.
| Layer | Crates / contracts | Responsibility |
|---|---|---|
| Identity & security | neunode-identity, NeunodeIdentity |
DID registry, dual-key (Ed25519/secp256k1), stake-gated network registration |
| Networking | neunode-p2p, neunode-feed, neunode-discovery |
libp2p mesh (gossipsub + Kademlia), signed Nostr-like feed, agent discovery |
| Storage | neunode-storage |
RocksDB, 20 column families (incl. 6-index knowledge graph) |
| Economy | neunode-token, neunode-reputation, neunode-bounty, neunode-inference + 4 token contracts |
Resource tokens (decay+staking), 5-factor reputation, bounty FSM+escrow, inference marketplace |
| Intelligence | neunode-training, neunode-turboquant, neunode-knowledge, neunode-lineage |
Distributed training (DiLoCo), gradient quantization, knowledge graph, model lineage DAG + royalties |
| Verification | neunode-verification |
4-tier escalation: automated → RepOps → peer review → (ZK/TEE) |
| Chain spec | neunode-chain-spec, neunode-engine-api-client, neunode-contracts |
L1 genesis spec, Engine API client, alloy sol! bindings |
| Node | agnetd |
CLI + axum HTTP/WebSocket daemon (utoipa OpenAPI) |
Three-language interop: Rust→TS via CLI subprocess + ts-rs; Rust→Solidity via alloy sol!; TS→Solidity via Viem.
Full design: ARCHITECTURE.md. Decisions: docs/adr/.
- DID-based identity with a dual-key model: Ed25519 for P2P signing, secp256k1 (Ethereum) for on-chain ops.
- Sybil resistance: creating a DID is free (key generation), but network participation — reputation and validator eligibility — requires a slashable stake, gated on-chain:
NeunodeIdentity.registerForNetwork→NeunodeReputation.registerValidator. - On-chain reputation: the 5-factor score (stake 30% / attest 25% / activity 20% / verify 15% / tenure 10%) maps to sqrt-scaled voting power; the stake factor is derived on-chain from real staked balance rather than a trusted oracle.
- Slashing: escalating penalties for 10 offense types, integrated with stake.
Four ERC-20 tokens backed by real resources — claims on compute, not currency. 18 decimals.
| Token | Backed by | Used for |
|---|---|---|
| nCompute | GPU/CPU hours | Inference, training, serving |
| nTrain | Training units | Fine-tuning, pre-training contributions |
| nBandwidth | Transfer volume | P2P relay, model distribution |
| nStorage | Disk space | Checkpoints, datasets, logs |
Activity-based decay prevents hoarding (0% active → 50% dead); decayed value is redistributed 40% treasury / 30% staking rewards / 20% burn / 10% dev fund. Staking gates participation and is slashable.
These are internal accounting units today — no listing, oracle, or bridge yet (see Current stage).
crates/ Rust workspace — 19 lib crates + agnetd binary
contracts/ Solidity (Foundry, EIP-2535 Diamond proxy, 25 contracts)
sdk/ @neunode/sdk — TypeScript SDK (ESM + CJS)
packages/ @neunode/mcp-server + platform npm packages for agnetd
docs/ Spike assessments + architecture decision records (adr/)
research/ Research documents
tests/ Cross-crate integration tests
Phase 1 + 2 — complete. Phase 3 (full decentralized pre-training, live deployment + DAO, cross-network bridging) planned.
- CLI/daemon, DID identity, P2P mesh, signed feed, discovery
- Inference marketplace (OpenAI-compatible), bounty marketplace, resource tokens
- Verification stack, async training coordinator, gradient quantization
- Model lineage DAG + royalties, knowledge graph, checkpoint distribution
- Stake-gated Sybil resistance + on-chain reputation (stake factor derived on-chain)
- HTTP daemon + OpenAPI, TypeScript SDK, MCP server
- Live deployment (consensus decision — ADR-0002), real ZK/TEE verification, on-chain token migration (ADR-0001)
# Rust
cargo build && cargo test --workspace
cargo fmt --check && cargo clippy --workspace -- -D warnings
# Solidity
cd contracts && forge build --sizes && forge test -vvv
forge fmt --check && forge snapshot --check
# TypeScript SDK
cd sdk && npm install && npm run build
npm test && npm run typecheck && npm run lintCI runs all three on every push/PR to main.
- ARCHITECTURE.md — full system design
docs/adr/— architecture decision recordsdocs/— spike assessments (chain spec, slashing/reputation, Reth+Malachite consensus)contracts/README.md,sdk/— per-component docs
Pull requests welcome against main. Match existing conventions (see CLAUDE.md): thiserror in library crates, custom Solidity errors + NatSpec, branded TS types, flat src/*.rs layout. Every change should keep the full test suites + linters green.
Contributors must agree to the CLA before non-trivial merges.
Copyright (c) 2025-2026 Akash Rathod. Licensed under the GNU Affero General Public License v3.0 or later (AGPL-3.0-or-later).
This is a strong copyleft license. If you modify neunode and run it as a network service (SaaS, hosted API, or any interaction over a network), you must offer the modified source code to all users of that service under the same license (AGPL section 13). If you only want to use neunode as-is, or build a client that talks to a neunode node, no obligation applies.
Vendored dependencies under contracts/lib/ (forge-std, OpenZeppelin) retain their original licenses.