0G Integration

ClawMind uses four 0G components in production: Compute, Storage (reports), Storage (memory), and Chain. This page explains how each one is wired into the pipeline.

0G Integration

ClawMind’s production path is built on the 0G stack: LLM agent inference uses 0G Compute, reports and memory receipts use 0G Storage, and report hashes are anchored on 0G Chain. Local fallbacks exist only for development or misconfigured deployments, and they are surfaced as fallback providers in the API.

All integrations run on 0G Mainnet (Chain 16661). The active v4 signed registry is 0x24bAAC6720ae5B01A1CC90eCC1C15AFcb903E121.

---

Component Map

User task
   │
   ▼
0G Compute ──────── routes LLM agent inference
   │
   ▼
0G Storage ──────── stores final report JSON → returns 0g:// URI
   │
0G Storage ──────── stores memory index → updated after every run
   │
0G Chain ────────── records hash + score + EIP-712 signature on-chain

---

0G Compute

ClawMind routes LLM agent inference through the 0G Router. Memory retrieval and memory writing use local embeddings plus 0G Storage, while Planner, Researcher, Risk, Architect, Critic, and Final use the router.

Parameter	Value
Endpoint	https://router-api.0g.ai/v1/chat/completions
Model	deepseek/deepseek-chat-v3-0324
Env var	ZERO_G_COMPUTE_ENDPOINT, ZERO_G_COMPUTE_API_KEY

The LLM-backed agents share the same router endpoint. The router handles model dispatch and load balancing across 0G Compute nodes.

How to verify compute is active:

curl https://clawmind-puce.vercel.app/api/judge

Look for "integration": { "compute": { "provider": "0G_COMPUTE", "status": "active" } } in the response. If the provider is LOCAL_FALLBACK, the router key or endpoint is missing.

---

0G Storage — Reports

After the Final agent produces a report, ClawMind serialises it to JSON and uploads it to 0G Storage. The storage layer returns two identifiers:

• Root hash — a content-addressed hash of the report JSON
• 0g:// URI — a permanent reference in the format 0g://<root-hash>

Both are shown in the Integrity Panel after every run and are included in the on-chain transaction.

Parameter	Value
Env var	ZERO_G_STORAGE_ENABLED, ZERO_G_STORAGE_PRIVATE_KEY
Output	provider: "0G_STORAGE" + storageUri: "0g://..." in the decision receipt

Retrieve a report by URI:

curl -X POST https://clawmind-puce.vercel.app/api/report/retrieve \
  -H "Content-Type: application/json" \
  -d '{"storageUriOrRootHash": "0g://your-root-hash"}'

Retrieve a report by root hash:

curl -X POST https://clawmind-puce.vercel.app/api/report/retrieve \
  -H "Content-Type: application/json" \
  -d '{"storageUriOrRootHash": "0x..."}'

If ZERO_G_STORAGE_ENABLED is not set to true, reports are returned in-memory only and are not persisted. The on-chain anchoring step will also fail.

---

0G Storage — Memory

ClawMind maintains a persistent memory index across runs. After the Final agent writes its report, the Memory writer agent compresses the key findings into a structured memory entry and appends it to the index.

On the next run, Step 1 (Memory retrieval) performs semantic search over this index and injects the most relevant past analyses into the Planner’s context.

Parameter	Value
Storage	Same 0G Storage node as reports, separate index file
Retrieval	Semantic search over compressed memory entries
Env var	Same ZERO_G_STORAGE_PRIVATE_KEY

How to verify memory is active:

curl https://clawmind-puce.vercel.app/api/judge

Look for "memory": { "semanticRetrievalActive": true } in the response.

The memory index receipt is shown in the UI separately from the report receipt. Both receipts include a 0g:// URI.

---

0G Chain

The most critical integrity layer. After the report is stored on 0G Storage, ClawMind submits an on-chain transaction to AnalysisRegistry.sol on 0G Chain (Chain 16661).

The transaction records:

Field	Description
taskHash	Hash of the original analysis task
reportHash	0G Storage root hash for the report JSON
score	Final numeric score (0–100)
recommendation	GO / INVESTIGATE_MORE / NO_GO
storageUri	The 0g:// URI from the Storage step
timestamp	Submission time bound into the signed payload
operatorSig	EIP-712 signature from the authorised operator wallet

Contract address:

0x24bAAC6720ae5B01A1CC90eCC1C15AFcb903E121

View on 0G Explorer

Inspect all recorded analyses, transaction hashes, and operator signatures.

How EIP-712 signing works:

The operator wallet signs a typed data payload before every recordAnalysis call. This means every on-chain entry is:

1. Tied to a specific operator address
2. Verifiable without trusting the ClawMind backend
3. Detectable if tampered — a changed report hash will not match the stored signature

# Verify operator signature in Judge Mode
curl https://clawmind-puce.vercel.app/api/judge
# Look for "registryMode": "SIGNED_OPERATOR" and "signatureVerified": true

Environment variables:

ZERO_G_NETWORK=mainnet
ZERO_G_ANALYSIS_REGISTRY_ADDRESS=0x24bAAC6720ae5B01A1CC90eCC1C15AFcb903E121
ZERO_G_ALLOW_LEGACY_REGISTRY_WRITES=false

ZERO_G_ALLOW_LEGACY_REGISTRY_WRITES must be false in production. Setting it to true bypasses EIP-712 signing and produces unauthenticated writes.

Earlier v3 registry deployments are historical. The public app, /stats, /api/judge, /analysis, and the MCP flow all use the v4 signed registry above.

---

OpenClaw Manifest

ClawMind exposes an OpenClaw manifest — a machine-readable description of the agent pipeline, its artifacts, and its security policies. This makes ClawMind composable with other agent systems in the 0G ecosystem.

# YAML format
curl https://clawmind-puce.vercel.app/api/openclaw/manifest

# JSON format with live 0G evidence
curl https://clawmind-puce.vercel.app/api/openclaw/manifest?format=json

The JSON format includes live evidence fields: the current contract address, pipeline step count, memory status, and recent analyses — all pulled at request time.

The manifest is defined in openclaw.yaml at the root of the repository.

---

Full Verification Checklist

Run these checks to confirm all four 0G integrations are live:

Check	Command / Location	Expected
Compute is active	GET /api/judge → integration.compute.status	active
Pipeline has 8 steps	GET /api/judge → integration.openClaw.pipelineSteps	8
Memory is active	GET /api/judge → memory.semanticRetrievalActive	true
Contract address matches	GET /api/judge → integration.onChain.contractAddress vs .env.example	Identical
Live stats are public	Open /stats	Signed registry, memory, critic, and MCP metrics are visible
Reports are persisted	Run analysis → decision receipt	provider: "0G_STORAGE" + 0g:// URI
On-chain anchoring works	Run analysis → open tx from on-chain receipt	Transaction visible on 0G Explorer
Operator is authenticated	On-chain receipt or Judge Mode	SIGNED_OPERATOR + valid signature
Integrity is checkable	Compare UI hash with on-chain hash	Hashes match

---

Deploying the Registry

If you are self-hosting ClawMind and need to deploy your own AnalysisRegistry.sol:

# Install Foundry first, then:
git submodule update --init --recursive
node scripts/deploy-registry.mjs

The deployer wallet is automatically authorised as the first EIP-712 operator. Replace ZERO_G_ANALYSIS_REGISTRY_ADDRESS in your .env with the deployed address.