0G APAC Hackathon MVP
Live on 0G MainnetVerifiable Agent Memory Vault
Verifiable memory infrastructure for autonomous AI agents on 0G.
Store agent memory and execution logs on 0G Storage, anchor proof hashes on 0G Chain, and keep the product usable while storage propagation catches up.
Live demo checklist
Submission proof flow
Workflow
Create Agent → Anchor Memory → Verify Proof
The core loop stays available even while storage indexing is still propagating.
Create Agent
Register identity and metadata roots on 0G Chain.
Anchor Memory
Attach memory and execution-log proofs to the agent record.
Verify Proof
Review hashes, propagation status, and explorer activity.
Architecture
How a proof moves through the system
Live wallet actions stay on 0G Chain, while the API handles storage upload and proof retrieval.
Wallet
Next.js Frontend
AgentMemoryVault on 0G Chain
Next.js API
0G Storage SDK
0G Storage Indexer
Proof Verification
Developer Integration
Fit VAMV into the agent workflow you already have
Use Verifiable Agent Memory Vault as a memory proof layer beside your runtime, not as a replacement for your model, tools, scheduler, or vector database.
Keep your agent runtime
Let the agent keep using its current tools, vector store, scheduler, and model provider.
Capture memory events
When the agent creates or updates important memory, send that payload to VAMV.
Anchor a proof
VAMV stores the artifact path and anchors the root, content hash, and reference on 0G.
Continue the workflow
Your agent app keeps running normally, now with a verifiable memory trail.
Research Agent integration path
See how VAMVault fits into your agent workflow.
Integration Examples
Practical patterns for agent builders
Anchor the memory events that explain important agent behavior. Your existing workflow stays intact; VAMV adds durable provenance at the moments that matter.
Research Agent
When: After each sourced research note or conclusion.
Anchor: Question, evidence summary, citation notes, and final memory state.
Verify: Reviewers can verify how the research memory changed before an output was produced.
Coding Agent
When: Before and after a plan, patch, review, or release note.
Anchor: Task state, code-change rationale, test result summary, and follow-up memory.
Verify: Teams can inspect which remembered context led to a later code decision.
Multi-Agent Handoff
When: When one agent passes task state to another agent.
Anchor: Sender state, handoff summary, receiver assumptions, and accepted memory root.
Verify: Builders can prove what state was handed off and whether the next agent advanced from it.
Autonomous Analyst
When: When the analyst updates forecasts, classifications, or risk notes.
Anchor: Input snapshot, analysis memory, update reason, and verification checkpoint.
Verify: Operators can trace how an analytical state evolved across runs.
Getting Started in 5 Minutes
Builder checklist
Start by anchoring one meaningful memory update. Expand from there as your agent workflow matures.
Connect a funded 0G wallet.
Register the agent identity once.
Create a memory event from your existing agent runtime.
Anchor the memory proof without changing the agent loop.
Update memory as the agent learns, then inspect the path in Transition Explorer.
Register Agent
Anchor Memory
Optional: generate memory with 0G Private Computer and store its receipt.
Storage indexing may take a few moments depending on 0G propagation.
Optional Foundry attribution
Attach a Foundry Ingot receipt to this memory execution history without changing the main 0G flow.
Owned Agents
Showing sample demo data. Connect a wallet to load your real owned agents from 0G Chain.
Proof Verification
Paste a root hash and expected content hash, or generate one from Anchor Memory.
Transition Explorer
Memory Evolution
Verifiable memory is not only about where an agent is today. It is about proving how an agent got here, state by state.
How an Agent Got Here
Choose an owned agent to read its memory path from the vault.
Connect a wallet and load owned agents to view real memory evolution. No sample transitions are shown here.