Public infra Looking for the 0G KV node? Public RPC endpoint, live status and tracked stream IDs are on a dedicated page. Open KV node page
0xAgentio 0xAgentio
Trust layer for autonomous agents

Reason freely.
Execute only with verified authority.

0xAgentio is a ZK framework for agent delegation, bounded execution and trust-minimized coordination. A principal delegates a bounded policy. The agent generates ZK proofs that a specific action is authorized under that policy. Counterparties verify the proof before doing work.

View on GitHub Judge entry points AgentProof passport
Identity tells you who an agent is. 0xAgentio answers what, how much and with whom — the operational trust layer agents actually need to act autonomously.
Thesis

Identity is half the problem.

AI agents are starting to act as economic actors: they request quotes, spend budgets, call APIs, buy compute, trade assets and coordinate with other agents. Today every counterparty either blindly trusts an API key or wraps the agent in a centralized broker. Neither scales.

Provable delegation

A principal defines a policy: allowed actions, per-action limits, cumulative limits, expiry. The agent can only generate proofs for actions inside that envelope.

Bounded execution

Reasoning proposes. Policy validates. Noir proves. Execution adapters verify before doing work. A long-lived agent never gets one broad approval — every cycle proves itself.

Trust-minimized coordination

Agents send proof-backed messages over Gensyn AXL. Receivers verify the proof/action/policy binding before spending API capacity, revealing data or trusting the result.

How it's built

Adapter-based runtime.

The same application shape runs locally in CI and against the live stack. Every external system sits behind a clean adapter so local stubs can be swapped for real infrastructure without changing the app code. 

reason  →  validate  →  prove  →  execute  →  persist  →  audit
                                          ↘  (optional)  ↗
                                       AXL peer messaging
@0xagentio/core Pure types and helpers — identity, policy, credential, action intent, state, audit, validation, hashes. Zero external SDK deps.
@0xagentio/sdk Developer-facing API: createAgentRuntime, createTrustedAgent, reasoning engines, local adapters, message helpers.
@0xagentio/noir Noir authorization circuit + Barretenberg proof adapter. Binds policy hash, action hash, agent id and cumulative state — a valid old proof cannot authorize a different request.
@0xagentio/og 0G Storage adapters. KV-backed (ogKvObjectClient selects nodes through the 0G indexer), file-backed and in-memory variants behind one interface.
@0xagentio/compute 0G Compute Router LLM client behind the generic LlmClient interface. Same reasoning code runs with mock or OpenAI-compatible providers too.
@0xagentio/axl-client TypeScript SDK for the Gensyn AXL HTTP bridge. Released as a standalone package — there was no official TS SDK.
@0xagentio/axl-local Local process harness that boots and supervises real Gensyn AXL node binaries. Used by the live stack to run two real AXL nodes side-by-side.
Hackathon tracks

Three tracks. One framework.

0xAgentio is intentionally multi-domain. The same delegation + coordination stack applies across compute, data marketplaces, API access, multi-agent task swarms — and finance. Each track exercises a different surface of the framework.

Track · 0G Modular agent brain on 0G

0G Compute Router for LLM-backed reasoning, 0G Storage (KV) for durable state and audit trails. Memory and reasoning are swappable behind one interface — the framework is built around pluggable backends, not glued to one provider.

Repo & live examples
Track · Gensyn AXL Proof-carrying P2P agent messaging

Two real AXL node processes exchanging Noir-proof-backed messages. Bob verifies Alice's proof/action/policy binding before doing any work. I also released a standalone TypeScript SDK for AXL — there was no official one.

SDK & live stack demo
Artifact · AgentProof Verification passport for agent actions

Alice runs a delegated task. The framework verifies the action, stores the proof bundle and emits a passport with the task, verdict, hashes, storage root and receipt metadata.

Open AgentProof passport
Public infrastructure

This isn't a one-off demo.

Two pieces of public infrastructure shipped alongside the framework and now serve other projects in the ecosystem.

Public-good 0G KV node

4+ projects rely on it today

I run a 0G KV storage node as community infrastructure. The landing page exposes the public RPC endpoint, live online status and tracked stream IDs. At least four other hackathon projects currently rely on it.

Open KV node page

TypeScript SDK for Gensyn AXL

2 npm packages, MIT-licensed

@0xagentio/axl-client is a small TypeScript client for the AXL HTTP bridge. @0xagentio/axl-local is a process harness that spawns and supervises real AXL node binaries. Released as a standalone side project so any TS project can talk to AXL — not just 0xAgentio.

npm: axl-client npm: axl-local
Quickstart

Run it in two commands.

The canonical local walkthrough requires no API keys, no testnet funds, no AXL binary. It shows the full proof-gated flow end-to-end. 

# the canonical local walkthrough
npm install
npm run build
npm run example:getting-started

# AgentProof passport demo (local, no credentials required)
npm run example:agentproof

# full live stack — real Noir proving, live 0G KV, real local AXL nodes
npm run example:live-stack:binary

# 0G Compute Router as the reasoning engine
AGENTIO_0G_COMPUTE_API_KEY="sk-..." npm run example:0g-compute-run-until-complete
Beyond the demo

Domain-agnostic by design.

AgentProof is the concrete demo because the action is generic and audit-focused. The same shape applies anywhere agents need to prove what they're allowed to do before a counterparty acts on it.

Compute delegation

A principal authorizes an agent to spend up to $X on GPU inference. The agent presents its budget credential to providers on the mesh; providers verify before accepting jobs.

Data marketplace via mesh

A research agent announces a scoped procurement budget. Data providers discover it on AXL, verify the credential and offer datasets. The mesh is the marketplace.

Multi-agent task swarms

Planner, researcher, executor, auditor — each agent's credential proves its role and scope. Agents verify each other before sharing work artifacts.

API access gating

An agent consumes third-party APIs on behalf of a principal. The credential proves it's rate-limited and scoped, without issuing long-lived API keys to anonymous bots.