What is Causal
Causal is experience memory for AI agents. It records what your agents tried, what happened, and what to change next time, so each one gets smarter and more efficient.
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 |
Why does it get better the more you use it?
Every session leaves something behind. A decision and the outcome it produced, an approach that worked, an approach that cost a day: each one becomes precedent the next agent reads before it acts. Capture runs on the same always-on rule as recall, so it happens while the work happens.
So the graph is worth more in month three than in week one, and what it is worth accrues to you. It belongs to your workspace, exports in an open format, and outlives the model underneath it.
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. Install 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 differs by who is using it. An operator gets continuity across sessions without re-explaining the same project every morning. A team building agents can make a failure a one-time event and inspect why behavior changed. Every new workflow in an organization inherits 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, GitHub Copilot, Gemini CLI, OpenCode, OpenClaw, and Hermes. In Claude Code, Cursor, Codex, OpenClaw, and Hermes, Causal registers as an MCP server plus an always-on rule, so precedent reaches the agent before it acts instead of waiting on a tool call; the rest take the memory skills today.
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 Install; what each connector ingests is on Agent memory with integrations.
What you can audit afterward
Every memory carries a receipt, and the graph it lives in 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.