Agent memory use cases by team

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. Four teams run agents against four different systems, and each one gets a different kind of precedent back.

Operations: the repeat order

Order desks and warehouses run on agents that act in the ERP. The exposure is the repeat: an order that went wrong once, placed the same way again, by an agent with no idea the first one happened.

Causal serves what the last mistake cost before the next one ships. Precedent arrives before the action fires, so the agent has the earlier order and its outcome in front of it while it is still deciding. Every similar order that follows gets it, not only an exact match. Any hold or override the agent places traces back to the incident that justified it. A second team that finds stock frozen in a warehouse gets the directive along with the freeze.

What comes back to the desk is the decision it already made and what that decision cost: the wrong variant shipped, the freight paid to return it, the confirmation step that would have caught it. SAP is where the action lands and where the record of it starts.

What does support agent memory change about a resolution?

Support agents inherit the fixes that closed tickets. Every resolution carries whether the ticket stayed closed, so a fix that reopened the next day arrives with that attached rather than as a validated answer.

A recurring issue collapses into one memory. The tenth ticket with the same cause does not come back as ten transcripts to re-read.

When a fix stops working, supersedence retires it everywhere at once. The retired experience stays in the graph with its history, and the record shows what replaced it and when, so an agent that acted on the old fix last month can still be explained. AI agent governance and audit trail covers how that reconstruction works.

The material is already in the tracker. A Jira ticket that reopened after a hotfix, or a Linear cycle that absorbed an incident mid-sprint, is an outcome the next support agent should have. A new agent on the team starts with every fix the team validated.

Sales: plays and handoffs

Deal agents carry the team's wins and losses: which play closed, which discount stalled, which objection kept returning. Plays carry their recorded outcomes rather than their author's confidence, so the agent can tell a play that is popular internally from one that converted. Forecasts sit on what converted before.

A handoff arrives with the whole relationship, first call to last renewal. When an account changes hands, the incoming owner's agent has the escalations that were open at the last renewal conversation and how they landed, without anyone reconstructing it from a CRM timeline. Salesforce holds the account and the renewal; Causal holds what happened around them and why.

That second half is usually the part that goes missing. A deal stalls at renewal over unresolved support escalations, and the reason lives in a ticket queue nobody thought to read before the call. Recorded as experience, it comes back as a condition on the next renewal rather than a surprise during the call.

What do coding agents inherit from the repo?

Coding agents in your repos inherit every approach that already failed there: the reverted migration, the flaky workaround, the deploy that took the site down. Tried once, avoided everywhere.

The ordinary failure is a path retried after it already failed, because nothing recorded the first attempt where the next agent would look. Failed approaches are served before an agent retries them.

Postmortems become memory the next agent consults, rather than a document nobody opens. A rollback's reason survives the person who knew it, which matters most on the change nobody remembers making. GitHub carries the reverted pull request, Notion carries the postmortem written after it, and both are outcomes the next agent should be working from.

Where the material comes from

Two places. Your agents produce it as they work, and connectors bring in experience from the systems the company already uses — Slack, GitHub, Jira, Linear, Notion, Salesforce, and SAP. Merged-then-reverted pull requests, reopened tickets, postmortems, and decisions that later shipped are experience the graph can start from before an agent has run at all. Agent memory with integrations covers what each system contributes.

None of this asks a team to move onto a platform. Causal installs into the harness the team already runs — Claude Code, Cursor, Codex, OpenClaw, and Hermes, with SDKs for anything else — and the systems above stay where they are.

Experience also crosses between these teams: an operations hold placed on one team's precedent has to be answerable to another team that never saw the original incident. Governance and audit trail walks through that end to end.