Decision Memory is the approved decision layer for human–AI teams. It stores the decisions, rules, skills, and authorizations that define how your organization works, serves the subset that applies to a given task to your AI agents, and lets those agents propose new decisions that a human approves before they become trusted memory.
That definition packs in the four things that make it different from the tools you already have, so it’s worth unpacking each one.
The problem it solves
Every AI agent you deploy is capable, fast, and tireless — and shows up to every task with no memory of how your organization already decided to work. Humans hold that memory in a few tenured heads. Agents rebuild context from scratch every task and discard it at the end. The layer the whole human–AI team should share simply doesn’t exist.
The result is work that is technically plausible but organizationally wrong: code that compiles and passes tests while quietly using a database driver you banned, skipping the repository layer you standardized on, or logging customer identifiers you decided never to log. Nothing in the repository told the agent what you had already decided.
What actually lives in memory
Decision Memory isn’t a pile of notes. It’s four governed object types:
- Decision — what was chosen, and why: the rationale, the evidence, and the alternatives you rejected.
- Rule — what must or must not happen: constraints, exceptions, and what needs approval.
- Skill — how a class of work is expected to be done.
- Authorization — who may do what: which actor, action, resource, and conditions.
One task usually touches all four. A single “store machine artifacts as JSON” decision comes with a rule (never store them in Excel), a skill (define the schema, validate, store an example), and an authorization (the agent may write the repo, but an external upload needs approval).
The loop: memory in, decisions out
Decision Memory works as a loop rather than a static document:
- Capture evidence — meetings, decisions, tickets, and the reasoning behind them.
- Govern — a human approves what becomes official memory.
- Serve — the subset of memory that applies to a task is rendered to the agent.
- Work — the agent does the task with that context.
- Write back — the agent proposes new decisions, applied rules, and open questions.
- Approve — returned only after a human decides what becomes trusted memory for next time.
The invariant across the whole loop is simple: AI proposes, humans approve. Agents retrieve permitted memory and submit candidates. They never approve organizational memory themselves.
What Decision Memory is not
| It is not… | Because… |
|---|---|
| a meeting note-taker | a note-taker captures what was said; Decision Memory preserves what was decided. |
| a generic chatbot | it answers from approved decision memory, not from raw content. |
| just an LLM wrapper | the product is the workflow — intake, candidate decisions, human approval, durable records, search, conflict checks, write-back. |
| cloud storage for Cursor rules | it’s one canonical registry that resolves what applies to a task, not duplicated per-tool files that drift. |
| a replacement for Jira or Confluence | it’s a decision layer across the tools you already use. |
That last point matters. In mature teams the problem often isn’t missing documentation — it’s that the context behind a decision gradually disappears, and decisions get buried inside pages that are hard to retrieve later. Decision Memory preserves decision-level history and makes it findable even when you don’t know the exact keyword.
How agents connect
Agents reach Decision Memory over MCP with four tools: dm.search_decisions (search approved decisions), dm.get_decision_context (retrieve permitted context for a task), dm.check_conflicts (detect contradictions), and dm.propose_decision (submit a candidate for human review). It runs alongside Cursor, Copilot, and Claude Code rather than replacing them.
Where to start
Most teams begin with one workflow and one decision domain. If you deploy coding agents, see why AI coding agents ignore team standards and the coding-agent alignment use case. If your challenge is scattered technical direction, see the strategy and architecture use case.
One team. One workflow. One memory loop.
Test Decision Memory with a single agent workflow in 2–4 weeks.