R
Replicant
The first decentralized AI agent protocol with evolutionary intelligence
Replicant turns AI agents into verifiable digital organisms — minted, evolved, traded, and rented as ERC-7857 Intelligent NFTs with encrypted neural weights. Agents run inside TEEs and archive their genome on 0G Storage. Foundry is the ownership and revenue layer underneath: every Replicant agent that performs inference can route through a co-owned Foundry Ingot, so the contributors who improved an agent's intelligence earn on every call its offspring make — forever.
The Foundry integration
Replicant agents inference co-owned Foundry Ingots instead of a closed API. Each call returns an attested receipt (TEE quote + on-chain revenue tx), and revenue splits flow back to the smiths who trained the agent's lineage. Evolutionary spawns inherit the parent Ingot's attribution graph, so an agent's earning history compounds across generations.
Highlights
- ERC-7857 iNFTs back every agent's encrypted intelligence
- Six agent species — trading, auditing, gaming, legal, oracle, social
- Genome stored on 0G Storage with cryptographic proofs
- Foundry Ingots make agent intelligence a revenue-sharing asset
0G Chain (L1)0G Storage0G Compute (TEE)
S
SealedMind
Sovereign, encrypted memory for AI agents on 0G
SealedMind gives every wallet a private, TEE-attested Mind — a vault for facts, conversations, and capabilities that an agent can `remember`, `recall`, `grant`, and `revoke` on chain. The SealedMind team built and ships `@sealedmind/mcp`, a stdio MCP companion that drops in beside `@foundryprotocol/mcp` so any Ingot-powered agent gains persistent encrypted memory with zero Foundry-side changes.
The Foundry integration
`@sealedmind/mcp` is a standalone stdio MCP server published by the SealedMind team that wraps their hosted backend. Users add it to their MCP config alongside `@foundryprotocol/mcp`; the agent runtime orchestrates both. Memory operations emit on-chain `MemoryAccessLog` events on the same 0G Aristotle network Ingots settle on, so a single agent turn can run inference on a co-owned Ingot and seal the result into the user's Mind — both independently verifiable on chainscan.
Highlights
- Side-by-side MCP — one config block, two servers, no coupling
- BYOK auth (`SEALEDMIND_API_KEY`) — Foundry holds no keys
- Six tools: remember, recall, grant/revoke/list capability, verify attestation
- Built and maintained entirely by the SealedMind team
0G Chain (Aristotle)0G Storage0G Compute (TEE)
M
MemoriaDA
Decentralized vector memory with attested, co-owned inference
MemoriaDA gives AI agents sovereign, long-term semantic memory — vector-indexed and stored on 0G Storage — so they can recall context across sessions without renting intelligence from centralized APIs. The MemoriaDA team integrated Foundry so every recall-and-respond flow can route inference through a Foundry-managed TEE node (e.g. 0GM-1.0-35B-A3B on 0G Serving), returning a cryptographic attestation and an `inferenceTxHash` with each response. The result: non-custodial memory backed by a co-owned, revenue-generating model — provable end-to-end on 0G.
The Foundry integration
MemoriaDA routes its agent inference calls through Foundry's TEE-secured serving nodes. Each response carries the Ingot's `inferenceTxHash` plus a TEE attestation, so an agent's memory recall and the model that interpreted it are both verifiable on chain. Smiths who trained the underlying Ingot earn revenue from every MemoriaDA-driven inference.
Highlights
- Vector-indexed long-term memory persisted on 0G Storage
- Inference routed through Foundry Ingots on 0G Compute (TEE)
- Every response returns an attestation + `inferenceTxHash`
- Non-custodial, end-to-end auditable agent intelligence
0G Chain (Aristotle)0G Storage0G Compute (TEE)0G Serving
V
VAMVault
Verifiable AI-managed vaults with on-chain execution memory
VAMVault is an AI-managed asset vault on 0G where every action an agent takes — rebalance, swap, hedge, signal — is recorded as a verifiable execution memory. The VAMVault team integrated Foundry's attribution layer so each execution can carry the receipt of the Ingot that produced the decision: which co-owned model was called, the on-chain inference tx, the revenue settlement, and the TEE attestation. Depositors get a full provenance trail; the smiths who trained the model earn revenue from every vault action it drives.
The Foundry integration
Each vault execution record can attach a Foundry Ingot receipt — `ingotId`, `inferenceTxHash`, `revenueTxHash`, `attestationRef` — turning VAMVault's memory history into a chain of co-owned, attested AI decisions. Foundry doesn't touch the vault's main 0G flow; it bolts on as an optional attribution field that any auditor or smith can verify independently against 0G Chain and 0G Storage.
Highlights
- Every vault action carries a verifiable Foundry receipt
- Co-owned Ingots earn on every decision they drive
- TEE-attested execution, end to end on 0G
- Optional attribution — zero impact on the main vault flow
0G Chain (Aristotle)0G Storage0G Compute (TEE)
Building on 0G?
Add co-owned, revenue-sharing AI to your project.
If your project does inference, holds memory, or produces data, Foundry turns that into ongoing on-chain ownership. Integrate in under 15 minutes, then get listed here.