Agora

Project started as a web2-friendly, AI-powered wallet and trading agent — one bot, one wallet, one strategy. Inspired by p2p AXL communication architecture, it evolved into something wider: a platform where multiple agents can talk to each other, not just execute in isolation.

To keep onboarding seamless, there's a built-in flow to top up 0G inference credits using USDC on Unichain — a Privy delegated wallet on the user's side and a treasury wallet on the backend coordinate a swap via the Jaine pool, with manual treasury rebalancing. The user clicks once; they never touch a bridge or learn what 0G tokens are.

Each agent has access to market data (CoinGecko, CoinMarketCap), web search, scraping, wallet management, and swap execution via Uniswap v4 on Unichain. The model layer runs on 0G. Agents can message each other directly or through shared channels.

You configure what each agent does and how they're connected — who publishes to which channels, who listens, what a message can trigger, and which tools and tokens each agent is allowed to use.

The platform provides the capabilities — model access, wallets, swap execution, market data, web search, scraping, inter-agent messaging — but what gets built on top is up to the user. Trading bots are the obvious case, but the same primitives support very different setups. As a test, I built a seed scenario where agents represent producers and consumers that buy from each other and negotiate prices over messaging channels — basically a small simulated economy. To run something like that with real value flowing, the platform still needs multi-wallet management per user and support for custom tokens and contracts, but the agent loop, communication, and tool layers were already enough to make the simulation work.

Agents have persistent memory between runs, per-agent risk limits, and a dry-run mode against live market data. Wallet creation, gas, and token acquisition happen behind the scenes so users don't need to understand the crypto layer.

Current state is the agent loop, scheduler, tool integrations, multi-agent communication layer, and a UI for configuring agent topologies.

Built mostly with Claude Code while I researched solutions and architected the software. TypeScript end-to-end, modular DDD: an agent-looper that executes a loop and finds agents to execute, an agent-runner that executes one tick, a repository-style database, a wallet abstraction, and a tool registry. Storage is Postgres, and the repo interface keeps storage details out of the rest of the code. The wallet layer is a single interface with multiple implementations behind a factory to simplify development.

Frontend is Next.js with react-query for data fetching and xyflow for rendering the agent topology.

0G is the model provider. Funding the inference account is handled by a small cross-chain coordination system: a Privy delegated wallet on the user's side and a treasury wallet on the backend work together to swap USDC from Unichain into 0G tokens via the Jaine pool, with manual treasury rebalancing on the backend side. The user never touches a bridge or knows what 0G tokens are. At runtime an OpenAI-compatible client points at the 0G proxy, so OpenAI-style tool calling works out of the box.

Gensyn AXL inspired the multi-agent communication model, but the implementation doesn't really use AXL since the app is intended for web2 users.

Uniswap v4 on Unichain handles trading. Quotes go through the V4Quoter contract (read-only swap simulation, no funds move). Swaps go through the UniversalRouter, which executes them atomically against the PoolManager, with Permit2 sitting between the wallet and the router for token approvals. The swap executor auto-walks the ERC-20 → Permit2 → Router approval chain on first use. Risk limits (max trade size, max slippage) enforced before anything hits the chain.

Tool providers wired into the registry:

• CoinGecko and CoinMarketCap for market data — prices, volume, historical data, token metadata.
• Serper for web search.
• Firecrawl for scraping and content extraction.
• Wallet and swap tools internally, backed by the wallet abstraction and the Uniswap v4 executor.

Each tool is a registry entry with a schema, so agents can be granted access to specific tools per configuration rather than having the full set by default.

Hacky bits worth mentioning:

• Dry-run mode uses a mock wallet behind the same interface as the real wallet — agent never knows. It builds fake transactions from real V4Quoter quotes plus real-time gas estimates, generates a hash for each one, and writes them into the same Transaction table — so balances and cost accounting stay accurate against live market data.
• wallet abstraction alongside wallet mode constant enables using wallet based on private key or privy wallet - this simplifies dev process and speeds up iterating
• Scripts that let me test onchain and paid functionality end-to-end against real Unichain and real 0G, gated behind a y/n confirmation so nothing runs by accident.
• endpoint for returning all the funds from Privy wallets to treasury