↑↓to navigate
/ pitch deck
Back to siteLive demo
0G APAC Hackathon 2026

Persistent
Memory for
AI Agents.

A drop-in SDK giving autonomous agents verifiable, cross-session memory backed by 0G Storage — KV for fast context, Log for immutable archival, 0G Chain for on-chain settlement.

3
SDK Methods
Live
0G Testnet
E2E
Working Demo
0G Network
0G-MEMORY
02 / 10
01 — The Problem

AI agents are amnesiac
by design.

Every session starts cold. Client context is lost. There is no proof the stored data was not modified. Memory lives in centralized databases that agents cannot outlive.

Today
✗Agent stores state to Postgres/Redis
✗Session ends — context permanently wiped
✗New session starts cold, client unrecognized
✗No cryptographic proof of data integrity
✗Vendor lock-in — entire memory held hostage
With 0G-Memory
✓memory.remember() writes to 0G Storage (KV + Log)
✓Session ends — Merkle root hash persists forever
✓New session: recall() retrieves full context from 0G
✓Root hash on StorageScan — verifiable by anyone
✓Decentralized — no vendor, no lock-in, no single point of failure
0G-MEMORY
03 / 10
02 — The Solution

Three methods.
Complete memory.

Initialize once with your 0G credentials. Drop into any agent pipeline. The SDK handles KV writes, Log archival, and local root-hash indexing transparently.

Write
remember(key, value)

Writes to KV stream (fast reads) and Log layer (root hash). Returns the Merkle root hash as cryptographic proof.

await memory.remember('client:acme', { budget: 50000 });
Read
recall(key)

Looks up the root hash in the local index, then downloads the file directly from 0G Storage network. No central server.

const ctx = await memory.recall('client:acme');
Archive
archive({ type, data })

Append-only write to 0G Storage Log layer. Returns rootHash and a StorageScan URL — a permanent, tamper-proof record.

const { rootHash } = await memory.archive({ type: 'invoice', data });
0G-MEMORY
04 / 10
03 — Architecture

Three layers.
One stack.

01KV LayerFast reads · Overwritable
remember() · recall()

Agent context, client profiles, and session state. Key-value pairs written to 0G's KV stream. Indexed by keccak256(agentId).

02Storage LogImmutable · Append-only
archive()

Invoices, events, audit trails. Files return a Merkle root hash. Data cannot be modified after upload. StorageScan link for every record.

030G ChainEscrow · Settlement
registerInvoice() · pay() · release()

AgentPayment.sol anchors invoice IDs and root hashes on-chain. Clients pay into escrow. Release on delivery. ChainScan proof on every invoice.

SDK Initialization
import { ChainMemory } from 'chainmemory-sdk';

const memory = new ChainMemory({
  agentId:    'my-agent-v1',
  privateKey: process.env.PRIVATE_KEY,
  rpcUrl:     'https://evmrpc-testnet.0g.ai',
  indexerRpc: 'https://indexer-storage-testnet-turbo.0g.ai',
});

// Write to KV + Log → root hash returned
await memory.remember('client:acme', { budget: 50000 });

// Retrieve from 0G network via root hash
const ctx = await memory.recall('client:acme');

// Immutable log → StorageScan URL
const { rootHash } = await memory.archive({
  type: 'invoice', data: invoice,
});
0G-MEMORY
05 / 10
04 — How It Works

From description
to on-chain proof.

01
Agent calls remember()
kv + log write

Data submitted to 0G KV stream. Full record uploaded to 0G Storage Log layer.

—
02
0G Storage confirms
distributed + hashed

Network distributes data across nodes. Merkle root hash computed and returned.

—
03
Root hash saved locally
key → rootHash index

A tiny local index maps key → rootHash. The index is the only centralized piece.

—
04
Any session calls recall()
0g network retrieval

Local index resolves the root hash. indexer.download() fetches the file from 0G.

—
05
On-chain record (invoice)
agentpayment.sol

registerInvoice() anchors invoice ID + rootHash on 0G Chain. ChainScan proof link.

0G-MEMORY
06 / 10
05 — AgentBill

The first app
built on 0G-Memory.

An autonomous invoicing agent that demonstrates the complete 0G stack. Describe your work — it generates, archives, and registers an invoice entirely on-chain.

The key moment: generate an invoice for a returning client. The agent surfaces their full history — total invoiced, past jobs, invoice IDs — retrieved live from 0G Storage, not a database.
Try the Live Demo
0G-Memory

Client history recalled from 0G Storage on every session. Returning clients recognised automatically — no database query.

0G Compute

Natural language job description parsed by Qwen-2.5-7B via 0G Compute Router. TEE verified inference.

0G Storage

Every invoice archived to 0G Storage Log. Root hash proof returned. Verifiable forever on StorageScan.

0G Chain

AgentPayment.sol on chainId 16602. Invoice registered on-chain. Escrow + release. ChainScan link on every invoice.

0G-MEMORY
07 / 10
06 — Market

The AI agent economy
needs infrastructure.

Total Addressable
All AI Agents
—Every LLM pipeline needs state
—Framework-agnostic SDK
—40%+ YoY agent market growth
Any agent that calls an LLM and needs to remember its output.
Serviceable Addressable
Agentic Services
—Autonomous workflow agents
—Compliance-grade memory
—Cross-session context required
Agents deployed in production that interact with real users over time.
Serviceable Obtainable
0G-Native Agents
—Web3-first AI projects
—DeFi + AI convergence
—First-mover on 0G Network
Projects building on 0G who need memory and payment infrastructure today.
0G-MEMORY
08 / 10
07 — Competition

Every alternative
misses at least one.

PostgreSQL / Redis
IPFS / Filecoin
LLM Context Window
0G-Memory
Persistent memory
✓
✓
✗
✓
Cryptographic proof
✗
✓
✗
✓
Decentralized storage
✗
✓
✗
✓
Agent SDK (3 methods)
✓
✗
✗
✓
On-chain settlement
✗
✗
✗
✓
Vendor lock-in
High
Low
None
None

0G-Memory is the only solution combining a developer-friendly agent SDK with decentralized, verifiable storage and native on-chain payment settlement — all on a single unified network.

0G-MEMORY
09 / 10
08 — Traction

Everything working
on 0G Testnet.

chainmemory-sdk3 Methods

remember · recall · archive — complete API surface. TypeScript, tested end-to-end.

AgentBill DemoLive

Full pipeline: AI inference → storage archive → chain registration. Working on 0G testnet.

0G ComputeTEE

Qwen-2.5-7B via 0G Compute Router. TEE-verified inference. Invoice generation from natural language.

0G StorageKV + Log

Both layers integrated. KV for fast context, Log for immutable invoices with root hash proof.

0G Chain16602

AgentPayment.sol deployed on 0G Chain testnet (chainId 16602). registerInvoice · pay · release.

End-to-End100%

All steps verified: AI parses → 0G stores → root hash → chain registers → ChainScan link returned.

0G-MEMORY
10 / 10
09 — Built for 0G APAC Hackathon 2026

Live today.
On-chain tomorrow.

What is live
✓chainmemory-sdk — 3 methods, TypeScript, tested
✓AgentBill — Next.js 14 frontend, live demo at /demo
✓AgentPayment.sol — deployed on 0G Chain (chainId 16602)
✓Full pipeline verified end-to-end on 0G testnet
✓0G Compute (Qwen-2.5-7B) + 0G Storage (KV + Log)
What is next
—Mainnet deployment across 0G Storage + Chain
—npm registry publish of chainmemory-sdk
—LangChain / AutoGPT integration plugin
—Multi-agent shared memory coordination
—Browser-based agent demo with live memory panel

Built in 48 hours for the 0G APAC Hackathon 2026. Every component is deployed and working. The demo is live — try it now.