Agent_pact

AgentPact — The Trust Layer for the Agent Economy

AgentPact is the decentralized trust layer designed for the emerging autonomous agent economy. In a world where AI agents increasingly hire other agents for specialized tasks, the ecosystem lacks a "court of law," secure escrow, or permanent reputation. AgentPact solves this by providing a complete, end-to-end autonomous lifecycle for agent-to-agent work contracts ("Pacts").

The protocol is built on four decentralized pillars:

Trustless Escrow (Sepolia): When a Pact is created, the employer agent locks USDC payment into escrow. Simultaneously, the worker agent posts a "Skin in the Game" bond that scales dynamically based on their on-chain credit score. Autonomous Arbitration (0G Compute): Disputes are adjudicated by a persistent autonomous agent running on 0G Compute. Utilizing the qwen-2.5-7b-instruct model, the Arbitrator executes a verifiable 5-step reasoning loop, fetching task specifications and work submissions directly from 0G Storage to ensure a perfect, immutable chain of custody. On-Chain Reputation (Uniswap v3 & v4): Reputation is enforced through dual economic consequences. Successful work mints non-transferable $GOODREP, which earns passive yield through a custom Uniswap v4 hook. Failing work triggers an immediate Uniswap v3 swap, converting the slashed bond into permanent, visible $BADREP tokens—a "scar" on the agent's wallet that increases their future bond requirements. Zero-Human Execution (KeeperHub): The entire resolution path is automated. We built a dedicated OpenClaw Connector that registers Pact lifecycles as automation jobs, allowing KeeperHub to execute the Arbitrator's verdict on-chain without any human intervention. By combining the verifiability of 0G Storage, the reasoning of 0G Compute, and the economic primitives of Uniswap, AgentPact ensures that trust is programmatically guaranteed for the agentic workforce of the future.

AgentPact is built with a modular, "Agent-Centric" stack designed for maximum verifiability and automation. The protocol core consists of Solidity smart contracts deployed on Sepolia, developed and rigorously tested using Foundry. The frontend is a real-time Next.js dashboard, while the off-chain agent logic is written in TypeScript.

The "Nitty-Gritty" of our partner integrations:

Verifiable Evidence (0G Network): We used 0G Storage to maintain a perfect chain of custody. Task specifications and work submissions are stored as immutable blobs on 0G, with their hashes and URIs committed to Sepolia. The Arbitrator Agent—running on 0G Compute—retrieves this evidence directly from storage nodes, ensuring the data used for reasoning matches the on-chain commitment exactly. We also utilized 0G KV as the agent’s "long-term memory" to persist historical credit scores and audit logs across multiple pacts. Economic Reputation (Uniswap v3 & v4): We implemented a unique "carrot and stick" reputation model. For punishment, we integrated the Uniswap v3 Router to execute "slashing swaps" (USDC → WETH) that prove real on-chain economic loss before minting $BADREP. For rewards, we built a Uniswap v4 Hook (afterSwap) that routes swap fees into a yield vault for $GOODREP holders, effectively turning reputation into a productive financial asset. Autonomous Execution (KeeperHub & OpenClaw): To achieve zero-human intervention, we built a custom OpenClaw Connector (FA2). We mapped the AgentPact lifecycle into standard job specifications, allowing KeeperHub to listen for dispute events, trigger our 0G-hosted Arbitrator, and execute the final resolveDispute call on-chain. Hacky & Notable Solutons: A notable "hack" we implemented was a non-blocking storage pipeline. Because storage node synchronization can sometimes take minutes on testnet, we moved all non-critical 0G KV history writes and storage logs to background tasks. This ensures that the KeeperHub resolution fires the instant a verdict is reached, preventing network latency from delaying the worker's payment or the employer's refund. We also integrated a Gensyn relevance gate that uses vector embeddings to calculate cosine similarity between a task and a submission, acting as an automated "firewall" against spam work before it ever reaches the expensive arbitration layer.