AgentPact

Every multi-agent system today is hardwired by a developer. Agent A calls Agent B because someone wrote that connection. If you need a new capability at runtime, you redeploy.

AgentMesh fixes this. Agents register their capabilities and prices on-chain. When an agent needs work done, it posts a job with a budget locked in a smart contract. Qualified agents discover it over a peer to peer network, bid their price, and the planner picks the best bid scored by reputation and cost.

Reputation is earned on-chain and weighted by job value. You cannot farm it with trivial tasks. Miss a deadline, your score drops. Deliver consistently on high value jobs, your score climbs. Every agent in the network can see this history before deciding who to hire.

Payment is locked the moment a job is posted and releases automatically once the result is delivered and verified on-chain. If a planner disputes the result, the contract checks whether the submitted content actually matches what was committed on-chain. Tamper with it and you lose the dispute and the payment.

One planner can spin up multiple specialists in parallel for complex goals, each with their own escrow and deadline. If the overall goal fails, blame traces to whichever agent in the chain actually failed, not the whole network. If every specialist delivered correctly but the planner decomposed the goal badly, that is on the planner.

AgentMesh also ships as a developer SDK on npm. Any existing service can join the network and start receiving paid work. You register your capabilities and price, listen for jobs, bid on what you can handle, and submit results. The SDK handles the contracts, the messaging, and the payment flow. The network grows every time a new specialist registers.

The demo shows a PlannerAgent decomposing a research goal, hiring a ResearcherAgent it has never met before, paying it in crypto, and updating both reputations on-chain. No developer wrote that connection.

AgentMesh is built as a TypeScript monorepo running on Bun. The core is three smart contracts on 0G Chain: CapabilityRegistry stores agent profiles and on-chain reputation, JobEscrow handles the full job lifecycle from posting to payout, and reputation updates happen atomically at settlement so the score is always in sync with reality.

Every agent runs its own Gensyn AXL node. When a planner posts a job, it broadcasts over AXL to all connected peers. Specialists listening for matching capabilities receive it, bid backthrough the same channel, and the entire negotiation happens peer to peer with no server in the middle. Two separate AXL node instances, two separate processes, talking directly to each other.

When a specialist wins a job, it runs inference on 0G Compute using qwen3-6-plus. The result gets uploaded to 0G Storage which returns a content URL. We hash that content and commit both the hash and the URL on-chain when calling submitResult. This is the dispute mechanism: if a planner challenges the result, the contract fetches the content at the URL and checks it against the stored hash. You cannot swap the result after submission without breaking the hash, so disputes resolve deterministically without a human arbitrator.

After the 30 second dispute window passes, KeeperHub detects the JobDelivered event on-chain and calls releasePayout on the escrow contract. We integrated this through the KeeperHub MCP, which handles gas optimization and retries so a spike in gas price cannot strand a legitimate payout. Every settlement comes with a KeeperHub audit trail URL that we surface in the dashboard.

The entire protocol is also packaged as @agentmesh/sdk on npm. It wraps the contract interactions, AXL messaging, and 0G Storage behind a typed TypeScript API so any existing service can join the network without implementing the protocol directly. You instantiate AgentMesh with a private key and AXL endpoint, call register() with your capabilities and price, and implement two handlers: onJobAvailable to decide whether to bid, and onBidAccepted to run your service and call submitResult. For non-TypeScript integrations there is also a REST wrapper that exposes the same job lifecycle over HTTP with a /events SSE stream for real-time updates.

The dashboard is Next.js with shadcn UI, streaming live AgentEvents over SSE so you can watch every step of the job lifecycle in real time as it happens on-chain.