Add verifiable provenance to your agent.
The causal chain you can watch on Ada isn’t a one-off — it’s a drop-in primitive. Wrap any agent decision in a single call: it reasons on 0G Compute, archives the trace on 0G Storage, and returns a public verify link. When your agent moves money or makes a high-stakes call, you can prove why.
import { createProvenance } from "@civ/provenance";
// Wires a real 0G Compute brain + 0G Storage.
const civ = await createProvenance();
// Wrap one agent decision — reasons on 0G Compute,
// archives the causal trace on 0G Storage.
const result = await civ.trace({
agent: "trading-agent-01",
question: "ETH broke resistance — long, short, or hold?",
memories: [{ id: "m1", summary: "ETH broke $3.2k on volume", importance: 8 }],
beliefs: [{ id: "b1", statement: "breakouts on volume follow through", confidence: 0.7 }],
actions: ["open_long", "open_short", "hold"],
});
result.decision; // { action: "open_long", reasoning: "…" }
result.drivers; // { memories: [{ id: "m1", weight: 0.8 }], … } — what drove it
result.verified; // true — cryptographically verified on 0G Compute
result.verifyUrl; // public, keyless link anyone can checkReason on 0G Compute
Your agent's decision runs through verifiable inference. The output is cryptographically attested — verified: true, not self-reported.
Archive on 0G Storage
The full causal chain — the weighted memories and beliefs that actually drove the call — is written to permanent, tamper-evident storage.
Share a verify link
Every decision returns a keyless verify URL. Anyone can independently replay and confirm it without trusting you, and without a private key.
“Why can’t I replace this with OpenAI + Postgres?”
Stores causality you have to trust. The operator can edit the row, drop the trace, or fabricate the reasoning after the fact. Nothing stops them.
Stores causality you can verify — without us. Reasoning is attested by 0G Compute (verified: true, not self-reported); the trace is archived on 0G Storage — keyless, replayable, tamper-evident. Delete our servers and the proof still stands.
Provenance is only a moat if it survives the operator being adversarial.
One architecture. Every agent.
The civilization is the easiest place to see it — but the same Memory → Belief → Decision → Event → verifiable-trace primitive wraps any autonomous agent.
- Source
- Memory
- Inference
- Conclusion
- Verifiable trace
- Signal
- Belief
- Trade
- Outcome
- Verifiable trace
- Knowledge
- Decision
- Action
- Audit trail
@civ/provenance runs on 0G today — a real civ.trace() reasoned on 0G Compute (verified: true) and archived to 0G Storage, then recovered keyless. verify it yourself →