The problem

Your AI agents are
flying blind.

They see the repo. They see the ticket. They do not see the decisions, constraints, and rules your team already agreed on — so they ship work that's clean, tested, and organizationally wrong.

Start a pilot See what's live today

Agents retrieve · humans approve

The blind spot

What the agent sees vs. what it needs.

What the agent sees
Task + code
  • The ticket
  • The repository
  • A local prompt / rules file
  • Generic patterns from training
What the agent needs
Approved organizational memory
  • Approved decisions & rationale
  • Active constraints & exceptions
  • What was rejected, and why
  • Authorization boundaries
The cost

“Implement tenant administration.”

The agent shipped clean, tested, idiomatic code. Tests passed. Nothing in the repo told it what the team had already decided.

Already approved by the team

Tenant admin rules

  • Structured tenant data stays in SQL
  • Uploaded files stay in SharePoint
  • Writes go through the repository layer
  • Never log customer identifiers
  • Schema changes require architecture review
What the agent shipped

Ready to merge, organizationally wrong

  • Stored file blobs in SQL
  • Bypassed the repository layer
  • Logged customer identifiers
  • Added an unapproved retry library
  • Changed the schema without review

The problem was never code quality. It was missing approved decision context.

The trap

You bought Cursor. You bought Copilot.
You didn't buy memory.

Meeting assistants

Preserve what was said

Not what became approved, or whether it still holds.

Confluence / SharePoint

Preserve pages

Not decision-level history, current status, or scope.

Jira / Product Discovery

Preserve work & early intent

Helps before delivery; discussions during implementation still scatter.

Enterprise search / RAG

Retrieve content

Not which approved decision applies now, or what conflicts with it.

Maintaining continuity between the initial intent and the final outcome remains challenging.— Product Owner, Self-Service BI · discovery interview
The product

Decision Memory is the approved decision layer for human–AI teams.

It turns scattered evidence into durable, human-approved decision records — serves the relevant subset into each agent task — and routes what the agent learns back for review.

How it works

The decision memory loop.

Nothing agent-generated becomes trusted organizational memory without human approval.

What is stored

Not notes. An approved decision record.

ApprovedDM-DEC-042 · v3
Decision
Uploaded tenant files stay in SharePoint; structured tenant metadata stays in SQL.
Why
Keeps large binary storage out of the transactional schema while preserving queryable, auditable metadata.
Scope
Tenant administration services · billing & onboarding repos.
Status
Current · owned by Platform Architecture · schema exceptions require review.
Preserved as decision memory
  • What was chosen
  • Rationale & trade-offs
  • Evidence & source links
  • Constraints & exceptions
  • Rejected alternatives
  • Owner, approver, status
  • Scope & change history

A page or ticket may contain pieces. Decision Memory keeps the decision current, linked, governed, and usable by agents.

The model

Four governed memory objects.

Live
Decision

What was chosen and why: rationale, evidence, rejected alternatives, scope, status, lineage.

Locally validated
Rule

What must / must not / requires approval. Versioned, linked to the decision behind it.

Locally validated
Skill

How a class of work should be done: patterns, playbooks, dependencies, write-back contracts.

Direction
Authorization

Which actor may do what, on what, under which conditions. Runtime enforcement stays separate.

Agent access

Agents retrieve. Humans approve.

Available MCP tools
  • dm.search_decisions
  • dm.get_decision_context
  • dm.check_conflicts
  • dm.propose_decision
Contract principle
Agents never approve memory.

The agent retrieves permitted memory and submits proposals. Imported or generated rules stay candidates until a human reviews them.

Not another tool

Not a note-taker, a search index, or a prompt file.

Meeting assistants

Capture what was said

DM preserves what became approved, and whether it still applies.

Jira Product Discovery

Capture early product intent

DM preserves continuity from intent through implementation and outcome.

Enterprise search / RAG

Retrieve relevant content

DM resolves which approved decision applies to this task, now.

Local rule files (.cursorrules, CLAUDE.md)

Store one dev's instructions

DM keeps governed provenance, versioning, ownership, and review.

Product truth

What's live, what's piloting, what's next.

Available now
  • Evidence intake
  • Candidate extraction
  • Human review & approval
  • Durable decision records
  • Search & Ask DM
  • Permission-aware access
  • Conflict checking
  • MCP: search / context
Locally validated
  • Governed Rule registry
  • Governed Skill registry
  • Immutable versioning
  • Lifecycle & provenance
  • Skill write-back contracts
Pilot workflow
  • Task-specific memory packages
  • Structured agent write-back
  • Applied decision refs
  • Follow-ups & outcomes
Direction
  • Full Authorization registry
  • Multi-object conflict detection
  • Cross-agent sync
  • Optional A2A memory agent
Where teams start

Two ways in. One decision layer.

Software engineering

Coding-agent alignment

Serve the coding agent the approved decisions and rules for this task, flag conflicts before merge, and return proposals for review.

Read the walkthrough
Standards & architecture

Strategy & architecture alignment

A drafting or reviewing agent arrives already briefed with the approved position, scope, rationale, and open questions — then returns alignment and conflict notes for expert review.

Read the walkthrough
Pilot metrics

Measure whether approved memory improves real agent work.

Decision recall

Can the team answer “why?” faster?

Time to reconstruct why a decision was made and whether it still applies.

Context coverage

Did tasks get the right memory?

Share of selected agent tasks with approved, scoped, permitted context.

Conflict capture

What got caught before merge?

Missing decisions, conflicting instructions, and stale rule copies routed to review.

Baseline and target values are agreed with you before the pilot starts. No numbers are asserted before they're measured in your environment.
Adoption

A decision layer — not another documentation process.

Sources · ingest selected evidence

No silent crawling

Jira · Confluence · Teams · Slack · GitHub · Email · Documents.

Agents · serve approved context

Works with your stack

Cursor · Copilot · Claude Code · internal copilots · MCP · future A2A.

Teams don't need to record every meeting. Decision Memory works from evidence teams already choose to preserve — the effort has to be minimal, or it won't get adopted.

The pilot

One team. One decision domain. 2–4 weeks.

01
Select domain
02
Import evidence
03
Approve memory
04
Connect agent
05
Run tasks
06
Measure
Questions

Answers before you ask.

What is Decision Memory?
Decision Memory is the approved decision layer for human–AI teams. It turns scattered evidence into durable, human-approved decision records, serves the relevant subset into each agent task, and routes what the agent learns back for human review.
How is it different from a meeting note-taker like Copilot?
Meeting assistants capture what was said. Decision Memory preserves what became approved — the decision, its rationale, evidence, scope, owner, and whether it still applies.
Isn't this just .cursorrules or CLAUDE.md?
No. Local rule files store one developer's instructions per tool and per repo; they duplicate, drift, and silently conflict. Decision Memory keeps governed provenance, versioning, ownership, and review — and resolves which approved decision applies to a task now.
Do agents get to change our organizational memory?
No. Agents retrieve permitted memory and submit proposals. Imported or generated rules stay candidates until a human reviews them. Agents never approve organizational memory, and runtime enforcement of actions stays separate.
How do agents connect to Decision Memory?
Over MCP: dm.search_decisions, dm.get_decision_context, dm.check_conflicts, and dm.propose_decision. It works alongside Cursor, Copilot, and Claude Code.
Decision Memory

Stop rebuilding context.
Start sharing memory.

Give your human–AI team one governed, durable source of truth for the decisions that matter.

Start a pilot See what's live today

Available for engineering, platform, architecture, and technical-strategy teams.