Three months on, nobody remembers why you decided something — and you're about to re-decide it, maybe contradicting a call from Q2. We build the living trail of which decisions are still in force and how they connect. AI maps and flags; a person decides what stands.
Common pain points
Decisions get recorded, but as a flat list — there is no way to see which are still in force and which were quietly replaced.
A new decision contradicts one from two quarters ago, and nobody notices until the contradiction causes a problem.
The same question gets re-decided every few months because no one can see it was already settled — and why.
"What's our current position on this?" means reading every old thread and guessing what still applies.
The reasoning that connects this decision to the three before it lives in one person's head — and leaves when they do.
Half the decisions in the log are superseded, but nothing marks them, so the team can't tell live from dead.
A decision memory system sits on top of the decision log you already keep — if you don't have one yet, that is decision capture, and we start there. It maps how your decisions connect (which build on, supersede, or reverse which) and keeps each one marked live, superseded, reversed, or under review, so the team can see what is actually in force. AI drafts the links and flags when a new decision contradicts a still-live one; a person confirms each link and owns what stands. It lives in the tools you already use — Notion, Obsidian, Docs — not a new app.
How we work
We start from the decisions you already record and map how they connect — which build on, supersede, or reverse which.
We connect AI to draft those links and the in-force status, and to flag when a new decision contradicts a still-live one — for a person to confirm.
We set the review cadence that keeps the in-force view current, and hand over a runbook the team operates inside its own tools.
What we build
Area 1
We map the links a flat log can't show — which decision builds on, supersedes, reverses, or depends on which. The map is what turns a list of records into a trail you can follow back to the reasoning, across quarters and across teams.
Deliverable
A decision relationship map: the build-on / supersede / reverse / depend-on links between your decisions, kept in the tools you already use.
Area 2
Every decision carries one status — live, superseded, reversed, or under review — maintained across the whole history, not set once and forgotten. This is the piece a decision log doesn't have: a flat log records each call, but it can't tell you which calls still stand today.
Deliverable
An in-force status model: each decision marked live / superseded / reversed / under review, with the owner who keeps it current.
Area 3
Before the team re-decides something, AI checks the new decision against the still-live ones and flags a likely contradiction — so a call that quietly reverses a standing decision gets caught on the way in, not after it has shipped. A person judges whether the contradiction is real and which decision wins.
Deliverable
A contradiction check: AI flags when a new decision may conflict with a still-live one, for a person to resolve.
Area 4
We connect AI to draft the relationship links, draft the in-force status, and flag contradictions. What AI may never do — decide what is in force, or supersede a decision on its own — is written down. AI proposes the trail; a person owns what stands.
Deliverable
An AI capability map with the limits written: what AI maps/flags/drafts, and what only a person confirms or marks superseded.
Area 5
On a set rhythm, the owner re-confirms which decisions still stand and marks the ones that have been overtaken — so the in-force view does not drift back into a flat list where live and dead decisions look the same. This is upkeep of the whole set, not a rule for reopening one decision.
Deliverable
A review cadence: how often the in-force status is re-confirmed, by whom, and how a superseded decision is marked.
Area 6
We hand the system over as a runbook: the relationship map, the status model, the contradiction check, the AI limits, and the review cadence — all living in Notion, Obsidian, or the docs the team already opens. The goal is a memory the team keeps without us, and without a new platform to adopt.
Deliverable
A runbook with the relationship map, status model, contradiction check, AI limits, and review cadence the team maintains in its own tools.
The team can see at a glance which decisions are still in force, so it stops acting on calls that were quietly replaced.
A new decision that contradicts a live one gets flagged before it ships, not after it causes a problem.
"Didn't we already decide this?" has a fast, readable answer — with the trail of why.
The reasoning that connects decisions survives the people who made them.
AI maps the links and flags the conflicts; a person owns what is in force, with the limit that AI never supersedes a decision on its own written down.
The memory lives in the tools the team already uses, with a runbook it maintains — no new app to adopt.
A decision log records each decision on its own — what, who, when, why, reversible. Decision memory sits on top of that log and adds what it can't show: how decisions connect over time, and which are still in force versus superseded or reversed. If you don't have a log yet, start with decision capture — this is the layer above it, not a replacement.
No. We don't sell or build a second-brain app, a decision-log platform, or anything with a new log-in. The memory lives in the tools your team already uses — Notion, Obsidian, Docs — as a structure, a status model, and a review cadence the team owns. There is no new platform to adopt.
No. A meeting-notes system turns one meeting's output into owned actions and routes decisions into your log. Decision memory works across all meetings over time — it is the connected trail and the in-force status of decisions once they are in the log, not the per-meeting pipe that puts them there.
Knowledge operations and internal search cover the whole of what your team knows — finding docs, keeping them current. Decision memory is the decision-only slice, with something a knowledge base doesn't have: a live status (in force / superseded / reversed) and the links between decisions. Search can query the memory; it isn't the memory itself.
No. Context consolidation gives one connected view of one account or project across tools. Decision memory is horizontal across the whole business — the operating decisions over time, regardless of which account or project they touch.
It does not include building your decision log from scratch (that is decision capture), an AI that decides what is in force on its own, a second-brain or knowledge-base platform, a project-management tool, or change-management training. If your team has no decision log yet, we say so on the call and start there first.
Decisions get made in Slack and email, never written down, then reopened weeks later. We define what counts as a decision and where the log lives — and AI dr…
Read moreOperating cadenceAI notetakers produce transcripts nobody acts on. We build the system on top: AI reads the notes, extracts the actions and decisions, and proposes an owner —…
Read moreOperating cadenceMeetings multiply because there is no rule for which conversations need to be live. We classify each recurring meeting and move status to a written async cad…
Read moreBook a 30-minute call to look at how your team's decisions pile up today and where the contradictions hide. We will talk through what a living trail of in-force decisions would look like on top of the log you already keep. If you don't have a decision log yet, we will tell you to start there first.
Book a 30-min call