AttestOS
Give your AI Agent a phone, mobile number, email, an inbox, and a proof trail. The operator workspace for autonomous AI agents — built on 0G.
视频
技术栈
描述
The Problem
AI agents can think, but they can't operate. They have no phone number to receive calls. No email inbox to handle messages. No wallet-bound identity to prove who they are. No private compute layer to reason without leaking data. And no proof trail to show what they actually did.
Today, if an agent summarizes an email, drafts a reply, or answers a phone call, there is zero verifiable evidence that the action happened. No hash of the output. No receipt on storage. No transaction on chain. The operator has to trust the agent blindly, and anyone auditing the agent later has nothing to verify against.
Agents need real-world interfaces and cryptographic accountability. They need a phone line, an inbox, an identity, a compute runtime, and a proof layer. AttestOS provides all five.
What AttestOS Does
AttestOS is the operator workspace for autonomous AI agents, that provide phone, email, identity and sever to agents built entirely on 0G. It gives any agent the surfaces and infrastructure it needs to actually operate in the real world:
- A live phone channel for real-time voice calls and messaging
- A managed email inbox with AI-powered summarization, drafting, and auto-reply
- A wallet-bound identity registered onchain with slug, domain, and proof vault
- A private compute runtime for sealed inference through 0G Compute
- A cryptographic proof trail where every AI action is hashed, stored, and registered onchain
The workspace binds to a single wallet. One MetaMask connect on the 0G Galileo Testnet, and phone, inbox, compute, identity, and proof are all attached to one operator.
How the Proof Pipeline Works
Every AI action in AttestOS follows the same six-step pipeline. No exceptions.
1. The operator triggers an action: Summarize, Draft Reply, Ask Copilot, or Auto Reply
2. The request is sent to 0G Compute for private inference using the GLM-5.1-FP8 model
3. The AI output is hashed with SHA-256, producing a resultHash
4. A JSON proof receipt is uploaded to 0G Storage, returning a storageURI (Merkle root hash) and a storageTxHash (the storage submission transaction)
5. The receipt root is registered onchain through the AgentBlackBoxRegistry contract, producing a chainTxHash
6. The dashboard displays all four proof fields with an ONCHAIN commit state
Both transaction hashes (storageTxHash and chainTxHash) are independently verifiable on the 0G Galileo block explorer. The resultHash is a content digest of the AI output. The storageURI is the Merkle root of the uploaded receipt. These are not simulated. They are real transactions on real infrastructure.
Communication Surfaces
Phone Channel: Powered by Saperly, AttestOS provisions a live phone line with inbound and outbound call support. The phone agent runtime builds prompt context from the call transcript, routes it through 0G Compute, and returns short, operator-style responses back to the caller.
Agent Inbox: Operators can create and manage multiple agent mailboxes (e.g., nova@attestos.dev). The inbox supports thread-based message views and four AI actions: Summarize, Draft Reply, Ask Copilot, and Auto Reply. Each action independently produces its own proof receipt with a unique set of hashes.
Operator Dashboard: A wallet-bound workspace that surfaces session stats, proof scores, service health indicators, phone console, and the Runtime Matrix showing the live status of every connected service.
Smart Contracts
AttestOS deploys three custom Solidity contracts on the 0G Galileo Testnet (Chain ID 16602):
AgentBlackBoxRegistry: The core session and receipt lifecycle contract. It manages session creation, payment recording, receipt submission, session completion with ratings, resource receipt registration, and automatic ProofScore calculation based on budget adherence, storage persistence, and session rating.
AgentIdentityRegistry: Wallet-bound agent identity. Registers an agent with a slug, domain, and proof vault URI. Tracks active registration state and cumulative proof score per agent.
ProofScoreLedger: Granular, auditable reputation scoring. Records score deltas with reason strings and receipt hash references. Supports paginated event history queries per agent.
Tech Stack
- Runtime: Node.js 22, Express 4, TypeScript 5
- Smart Contracts: Solidity 0.8.24, Hardhat, ethers v6
- Blockchain: 0G Testnet Galileo (Chain ID 16602, EVM Cancun)
- Compute: 0G Compute REST API (OpenAI-compatible, GLM-5.1-FP8)
- Storage: 0G Storage SDK (@0gfoundation/0g-storage-ts-sdk, MemData, Merkle trees)
- Payments: x402 Protocol (USDC pay-per-call on Solana + EVM)
- Phone: Saperly WebSocket + Webhook API
- Database: PostgreSQL
- Frontend: Vanilla HTML/CSS/JS, Inter + JetBrains Mono typography
- Container: Docker multi-stage build (Node 22 Alpine)z
What This Is Not
AttestOS is not an agent framework. It is not a chatbot wrapper. It is not a dashboard that displays mock data.
It is the operating layer that makes AI agents auditable, reachable, and verifiable. Every action is attested. Every receipt is anchored. Every proof trail is permanent.
Live Deployed Contracts
Network: 0G Galileo Testnet, Chain ID 16602
AgentBlackBoxRegistry
https://chainscan-galileo.0g.ai/address/0x85c0b0E0EE4Aa16cF6168F0dAfac38Fff0F31307
AgentIdentityRegistry
https://chainscan-galileo.0g.ai/address/0x6990aBC5e4e1607da9B947eF586B80048AD55f09
ProofScoreLedger
https://chainscan-galileo.0g.ai/address/0xF0569C299b6F27a1887dD4eD489c27CdF9B47dae
Verified Onchain Proof (Live Example)
Storage submission transaction:
Contract receipt registration transaction:
Deployer:
0x39a00B2a49EFd4443ad3DeCfA392C9488e3B1588
本次黑客松进展
We started with a basic idea: what if every AI agent action could be proven onchain? By the end of the hackathon, AttestOS became a fully working operator workspace with a live phone channel, managed email inboxes, wallet-bound identity, and a complete cryptographic proof pipeline, all running on 0G.
The biggest unlock was 0G Compute. Once we wired the OpenAI-compatible API into our inbox actions (summarize, draft, auto-reply), the entire proof flow clicked. Every AI output gets hashed, uploaded to 0G Storage as a Merkle-rooted receipt, and registered onchain through our AgentBlackBoxRegistry contract. We went from "maybe this works" to verifiable transactions on the Galileo explorer in a single night.
We deployed 3 custom Solidity contracts on 0G Galileo Testnet, built 258 API endpoints, integrated 0G Compute for private inference, 0G Storage for receipt persistence, and 0G Chain for onchain proof registration. The phone agent uses 0G Compute to generate real-time call responses. The inbox copilot uses it for thread summarization and reply drafting. Every action produces four verifiable hashes.
What surprised us most was how well the 0G stack fits together. Compute, Storage, and Chain are not separate products you have to glue. They feel like one infrastructure. We did not have to fight the tooling. The SDKs worked, the RPC was stable, and the chain finality was fast enough that we could register proofs in real time without blocking the user experience.
We genuinely enjoyed building on 0G. The documentation was clear, the testnet was reliable, and the combination of private compute plus onchain verification is something no other chain offers this cleanly. AttestOS would not exist without it.
融资状态
Bootstrapped. No external funding raised. Looking to raise a pre-seed to take AttestOS from testnet to production. Open to grants, ecosystem support, and angel investment