Voltaire Kit

VoltaireKit — first autonomous DeFi agents framework

See Pitchdeck >> https://drive.google.com/file/d/17am9q5Mmg4Ope8LJTKNKlrjW27Ixx_90/view

Building a DeFi agent today means three weeks of plumbing before you write a single line of strategy. Memory that survives restarts and is verifiable on-chain. LLM reasoning that doesn't hallucinate trades. Execution that emits an audit trail. Multiple agents coordinating without trampling each other.

VoltaireKit packages all of it. You import primitives. You ship.

But before I go any further, let me tell you about my experience building for this hackathon. When I wanted to start Voltaire, I started with a vision of a product that has an hybrid feature, and I never knew I was wrong.

I wanted to combine the strengths and deliverables of OG, Uniswap, and Kepperhub, and it worked. But after 4 days of building, I realized the OG team dropped their requirements later and I needed to build a framework that other DeFi developers and agents can use

So, I improvised and built VolataireKit

VoltaireKit ships six core primitives, importable from a single package:

Brain — LLM reasoning with 0G Compute and threshold fallback AgentMemory — hybrid persistence: SQLite (fast) + 0G Storage (verifiable) KeeperHubExecutor — verifiable swap execution with audit URLs UniswapRouter — quote and swap via Uniswap Trade API SwarmCoordinator — multi-agent shared state via 0G Storage NFTMinter — ERC-7857 agent identity for 0G Chain

A complete, production-shaped DeFi agent fits in ~50 lines of code.

It has a swarm coordination in its stack

A single agent is fine. Multiple agents on the same wallet collide — two of them might rebalance the same position twice, or fight over the same opportunity.

SwarmCoordinator solves this with a shared whiteboard pattern backed by 0G Storage. Agents publish signals, claim execution, and gracefully fall back.

Three agents. One wallet. Zero collisions. No central server. No message broker. State is verifiable on-chain via txSeq proofs.

This is the first DeFi multi-agent coordination primitive that uses 0G as the substrate — and it works only because 0G Storage is the only layer with cheap-enough writes, fast-enough reads, and verifiability all at once.

The first agent built on the kit: Voltaire AI

Voltaire AI is an autonomous ETH/USDC rebalancer running on Base Sepolia. It imports every primitive from @voltaire/kit. The rebalancer no longer reaches into a private codebase — it's a kit consumer. Refactor or fork the kit, and the agent reflects every change. That's the test of a real framework, and it passes.

What's verifiable on-chain right now?

60+ real 0G Storage uploads on Galileo testnet, each with a verifiable txSeq Live /swarm dashboard where any judge can trigger a coordination cycle and click through to the actual storage submission on storagescan-galileo.0g.ai Real KeeperHub audit URLs for every executed swap

Open-source MIT, public repo, real commit history showing iterative development

ERC-7857 — agent identity for 0G Chain VoltaireKit ships a minimal AgentNFT.sol and a TypeScript NFTMinter for ERC-7857 — non-transferable identity NFTs that encode an agent's role, reputation, and verifiable history. Designed for deployment on 0G Chain. This positions 0G ahead of Filecoin and Arweave (passive storage) and into the autonomous agent economy.

Why this matters

Frameworks beat apps. A framework lets a hundred more developers ship a hundred more DeFi agents. Each of those agents writes to 0G Storage, runs reasoning on 0G Compute, mints identity on 0G Chain. The substrate wins as the framework wins.

VoltaireKit is the first reusable agent framework with multi-agent swarm coordination as a first-class primitive — and it ships with a working agent on day one.

VoltaireKit is a TypeScript monorepo using npm workspaces. The agent and the framework live in the same repo so that "the rebalancer imports from the kit" is mechanically true — refactor the kit, the agent breaks. That constraint forces the kit to be a real reusable artifact.

Check the read.me files in GitHub repo

The tools and tracks we featured are as said below

How 0G is used

Three of 0G's products are wired in production:

0G Storage is the substrate for both AgentMemory and SwarmCoordinator. Every memory write is mirrored to 0G via the official @0gfoundation/0g-ts-sdk Indexer.

The KVMemory.set() call awaits the upload for swarm signals so the resulting txSeq can be attached to the signal record and surfaced through the API. The dashboard renders these as deep links to storagescan-galileo.0g.ai/submission/<seq>. 60+ uploads are live on Galileo right now.

0G Compute powers the Brain primitive. I hit DNS issues with compute-testnet.0g.ai from my environment (documented in FEEDBACK_0G.md), so the Brain ships with a deterministic threshold fallback that activates when Compute is unreachable. The agent runs uninterrupted regardless.

0G Chain is targeted by the NFTMinter + AgentNFT.sol ERC-7857 implementation. Metadata is hashed canonically, signed by the agent wallet, and uploaded to 0G Storage; the resulting URI is what gets minted to the contract on 0G Chain.

How KeeperHub is used

KeeperHubExecutor wraps the KeeperHub MCP server. Every swap executed by the rebalancer goes through it. The executor returns an audit URL and a retry count, both persisted in the rebalance event log and surfaced in the History page of the dashboard. Live runs on Base Sepolia produce verifiable BaseScan transaction hashes paired with KeeperHub audit URLs.

How Uniswap is used

UniswapRouter integrates the Uniswap Trade API for quote retrieval. Sepolia has no Trade API liquidity (documented in FEEDBACK.md), so the router ships with a mock quote fallback that maintains correct shape. When liquidity comes online, swapping the fallback for live quotes is a one-line change.

Making the framework genuinely reusable was the hardest part for me.

The temptation in a hackathon is to claim "framework" while shipping a tightly-coupled app. We forced separation by extracting core/* into packages/voltaire-kit/ with barrel exports, then refactoring the rebalancer's imports from '../../core/...' to '../../packages/voltaire-kit/src'. Now the kit and the agent are mechanically independent — the rebalancer is a third-party consumer of the kit. That single commit is what makes the framework story true.

so yeah, that's it