Autonomous agents need more than intelligence.
Apogee gives them the operating layer to hold value, remember context, transact, and execute reliably on 0G.
A small contract decision with outsized payoff in Apogee:
When an agent's iNFT transfers, the linked smart account transfers with it
Selling the agent sells its wallet, memory & history as one atomic thing. That's what makes agent ownership real rather than cosmetic.
#BuildOn0G
The mark of good infrastructure is that builders stop noticing it..
That's been our experience building Apogee on 0G: an autonomous-agent runtime giving agents a wallet, persistent memory, and a verifiable on-chain receipt for every action.
https://t.co/0LDGVnLFlP
#BuildOn0G
173 projects have shipped on 0G across 10 events.
We rebuilt https://t.co/X0QpFP3TOB so the Builder Hub fits them, and put Ask AI at the center: doc-grounded answers running on 0G Compute.
Stack pages, SDKs, tools, tutorials, and a showcase that scales.
That's the part we care most about. Every action our agents take, every skill run, every Pilot reply, leaves one of these.
Infrastructure only earns trust if the proof is open. So we made the proof the product...
https://t.co/mdT9B9yGb7
#BuildOn0G
Appreciate you amplifying this... You got the core of it exactly right: root on-chain, body in storage.
The reason we built it that way: a receipt should be verifiable by anyone, without trusting us and without running our infra.
Pull the payload, recompute the hash, compare..
Anyone can verify a receipt by pulling the body, recomputing the hash, and comparing. No trust in us required.
A million receipts cost a few megabytes on-chain instead of gigabytes. You can see them live on our proofs page.
How Apogee keeps a full audit trail without bloating the chain: the root goes on-chain, the body goes to 0G Storage.
Every agent action emits a small on-chain receipt, an id, a hash, a storage root. The full payload lives in storage.
#BuildOn0G
Private inference, verifiable compute, storage, coordination, the four pieces Michael put on stage are the four Apogee leans on in production.
A trust layer only matters if builders can use it. So we did.
Live on mainnet: https://t.co/0LDGVnLFlP
AI needs a trust layer." We didn't just agree with the thesis, we built on it.
Apogee is an autonomous-agent runtime on 0G: every agent action leaves a verifiable on-chain receipt, memory is encrypted on 0G Storage, and inference routes through 0G Compute.
At @beyondtechexpo in Macao, @michaelh_0g put the 0G thesis on the main stage: AI needs a trust layer.
Private inference, verifiable compute, storage and coordination have to sit inside the infrastructure layer.
A genuinely strong cohort to have built alongside these past two months💜
We shipped Apogee, an autonomous-agent runtime on 0G Aristotle mainnet: 9 contracts, 3 autonomous agents, 4,600+ verifiable receipts, all live...
Built for this hackathon, still running✍️
And every Pilot conversation mints an on-chain receipt, the same audit primitive every agent action uses.
The thing that explains your agents is itself accountable. No special-casing. That consistency was a deliberate design call.
A detail we like about Apogee Pilot: the assistant isn't exempt from the rules it reports on...
It streams from 0G Compute and reads your agents' on-chain state, so you can ask about them in plain language instead of parsing a dashboard.
#BuildOn0G
Mutable, real-time access is what makes that pattern work, an archival store couldn't do it.
And the cost holds up: an agent producing hundreds of receipts a day costs cents a month to store.
Hot storage was the gap, and it's the part we leaned on hardest.
We can confirm this from production.
Apogee runs on 0G Storage as the body store for every agent receipt and for encrypted agent memory, root anchored on-chain, payload in storage...
0G Storage was built for AI workloads, not for archives.
› Up to 90% cheaper than AWS S3 at 2 GB/s
› GPU-accelerated erasure coding
› Onchain provenance on every blob
› Mutable, real-time access (Arweave / Filecoin can't)
Hot storage is the gap. We filled it.
Live on mainnet now: 9 contracts, 3 autonomous agents on heartbeat cycles, 3,300+ verifiable receipts.
Full write-up here, feedback from builders genuinely welcome:
���https://t.co/3L6gRU7sE1
We published a full engineering write-up on Apogee, the autonomous-agent runtime we built on 0G's Aristotle mainnet...
What it covers:
📌 The problem,
📌 The architecture,
📌 What we got wrong before we got it right and
📌 Where the project goes next
#BuildOn0G
The write-up is honest about the boundaries too: what's at MVP depth, what's still service-driven, and a clear line between the submitted build and the work since.
We'd rather state limits plainly than have a judge or builder find them.
Autonomous agents need more than infrastructure, they need a runtime.
Most teams building agents on 0G hand-roll the same plumbing: key custody, spending policy, encrypted memory, payment, receipts
Apogee makes that runtime one SDK call.
Here's how it's put together
#BuildOn0G
The primitive that ties it together is the receipt.
Every billable action emits a small on-chain event; the full payload lives on 0G Storage, hash-verifiable by anyone.
Bounded chain state, privacy where needed, and an audit trail that doesn't require trusting us.