What is Causal
Causal is experience memory for AI agents — it records what your agents tried, what happened, and why, then serves that experience into the next decision.
The record is a graph: cause, effect, and the experience derived from them. Every entry is signed and traces back to the work that produced it, so an agent's reasoning can be audited after the fact.
What do cause, effect, and experience mean?
Cause is what was tried. Effect is what happened. Experience is what to change.
An experience is derived from the cause and effect beneath it, never asserted on its own. That derivation is what makes it usable later: when a new decision resembles an old one, the agent gets the lesson with the outcome that produced it attached, rather than a transcript to re-read.
The loop that produces the record:
observe → act → outcome → experience → better next decision
Why is experience memory for AI agents different from normal memory?
Normal memory can tell an agent what is true. Causal connects what the agent observed, what it did, what happened next, and what should change the next time similar conditions appear.
| Fact memory | Causal experience memory |
|---|---|
| Stores what the agent knows | Connects actions, outcomes, causes, and evidence |
| Returns an answer | Serves relevant precedent into the next decision |
| Replaces old values | Supersedes stale state without erasing its history |
| Leaves hidden platform state behind | Exports a portable, user-owned experience graph |
How a precedent reaches a decision
Four steps, in order.
- Capture decisions, durable context, actions, and observed outcomes from the work your agents do.
- Connect causes to effects in an experience graph rather than flattening everything into isolated facts.
- Serve the smallest relevant set of precedents when a new decision resembles something that happened before.
- Verify where each lesson came from, how it changed, and whether the graph remained consistent.
Serving is deliberate about size. Causal serves small, time-anchored payloads — a session-start briefing from the graph rather than a replay of every old conversation, and, before a retry, the failed attempt with its outcome attached. Recall happens before the agent acts rather than on a tool call. Recall and capture covers that path.
Causal serves precedent and evidence. Your agent still reasons about what to do.
Who it is for
Developers and teams running coding agents in production. On a team the graph is pooled across every agent, tool, and project, so one agent's outcome is available to the next — Harness setup covers how that handoff works. Pro and Pro+ take unlimited teammates with no seat fee, because Causal meters the memories agents write, not the people who read them.
What that buys:
- Operators get continuity across sessions without re-explaining the same project every morning.
- Teams building agents can make a failure a one-time event, and inspect why behavior changed.
- Organizations let every new workflow inherit what the company already learned, under explicit visibility, retention, and governance boundaries.
What each team does with it is on Agent memory use cases. The controls an organization sets around it are on AI agent governance and audit trail.
What it works with
Claude Code, Cursor, Codex, OpenClaw, and Hermes. Causal registers as an MCP server plus an always-on rule inside each one, so precedent reaches the agent before it acts instead of waiting on a tool call.
Python and TypeScript SDKs cover anything outside that list, and connectors for Slack, GitHub, Jira, Linear, Notion, Salesforce, and SAP land with the trial.
Per-harness detail is on Harness setup; what each connector ingests is on Agent memory with integrations.
What you can audit afterward
Every memory has a receipt. Every graph is yours.
- Source traceability and supersedence history
- Outcome-aware recall and causal replay
- Quarantine and taint propagation for compromised memory
- Owner-verifiable consistency and inclusion proofs
- Signed, offline-verifiable export in an open format
How a trail is rebuilt, and how a follow-up change stays traceable to the work that caused it, is on AI agent governance and audit trail. How a poisoned write is adjudicated is on Security and memory integrity.