Auto

Auto is an orchestration layer for decentralized AI that solves the black-box problem of onchain autonomous agents. We provide a framework to deploy sovereign agents that execute DeFi intents with verifiable accountability across compute, storage, and identity.

We establish a dual-layer identity framework. Human operators authenticate and log their actions via a best-effort L1 Ethereum ENS snapshot. Meanwhile, the autonomous smart contract vaults operate using L2 Basenames on Base, providing a discoverable onchain identity for the machine.

When an agent initiates a trade cycle, the system pulls live market data and uses Gemini to formulate a structured trading proposal. This intent is intercepted by our infrastructure and passed to the 0G Compute Router. The verifier stage runs a risk audit against the agent's historical memory; only after 0G Compute returns an explicit approval verdict does the system proceed.

The backend then queries the Uniswap Developer API to calculate optimal routing and construct the exact token swap calldata. We POST this payload to KeeperHub, which acts as our reliable execution engine to push the transaction and poll for completion on the Base Sepolia network.

The entire lifecycle is archived for total transparency. We package the L1 operator ENS, the LLM reasoning, the 0G Compute risk decision, the Uniswap route, and the KeeperHub execution hash into a structured JSON trace. This payload is uploaded to the 0G Storage Key-Value store and pushed entirely to the 0G Data Availability (DA) layer, creating an immutable audit trail for every autonomous action.

A side note: Due to some issues on our end, a wrong video file was uploaded in the demo video. Sadly, we could not correct that in time and are now stuck with an incomplete segment of what was supposed to be a detailed walkthrough. Please test the live demo directly. Thankyou

The backend orchestrator is built natively on Bun and Hono, using Drizzle ORM for PostgreSQL state management and viem for all on-chain interactions. The architecture operates as a highly specific sequential pipeline integrating our partner protocols.

For identity, we snapshot the L1 Ethereum ENS of the human operator server-side. To assign the agent its L2 Basename, we hit a roadblock with testnet resolution limitations. Our hacky solution was to transfer the Basename NFT directly to the vault address; while this permanently locks the address in the contract, it successfully binds the human-readable identity to the agent for the demo. We have documented this friction in our FEEDBACK.md.

The trade cycle begins by fetching live mainnet reference data from DexScreener. We feed this verbatim context to Gemini to generate a proposed trade direction and reasoning. This intent is immediately sent to the 0G Compute Router. The verifier-v1 stage evaluates the proposal against the agent's memory entries and returns a risk verdict.

Once approved, we build the route using the Uniswap Developer API. We built a resilient fallback mechanism into the routing phase: the backend attempts the primary /quote endpoint first, but if the Sepolia testnet API fails, it automatically falls back to querying QuoterV2 and SwapRouter02 directly to build exactInputSingle calldata. This ensures smooth testing on testnet while maintaining a production-ready solution for mainnet.

Because smart contracts cannot natively push their own transactions, we POST the finalized Uniswap payload to the KeeperHub API. The system polls the execution ID until KeeperHub confirms the contract call is completed on Base Sepolia and returns the transaction hash.

Finally, a dedicated background worker compiles the cycle log. It uploads the structured trace to 0G Storage KV, patching our database with the root hash. Immediately after, it pushes the full raw JSON trace blob, including the BaseScan explorer link, directly to the 0G Data Availability (DA) layer.