Decisions in Notion, Linear or ADR files vs where agents read them
By Soumen Sarkar · October 2026
Comparison. If your problem is writing decisions down well and finding them later, Notion, Linear or ADR files do that job. If agents keep building against decisions that are already written down, the gap is delivery: the decision has to reach the session working in that area, at the moment it starts. That is what Campfyrr does. Many teams need both.
What are you trying to fix?
If your problem is writing decisions down well and finding them later, keep them in Notion, Linear or ADR files. If agents keep building against decisions you already wrote down, the record isn't the problem. Delivery is: the decision has to reach the session working in that part of the product, when it starts work there. That is the job Campfyrr does. Many teams need both.
Here is how CTOs and product leads describe the problems, and which tool fixes each:
- "We decide things in meetings and nobody can find them a month later." Notion or Linear. A decision page or a decision on the project, with the context and the people around it, is a good record. Both now have MCP servers, so an agent can search them: Notion's hosted server lets Claude Code, Cursor and Codex search and read your workspace (Notion docs), and Linear's lets agents find and read issues, projects and comments (Linear docs).
- "Engineers need to know why the system is shaped the way it is." ADR files. Michael Nygard's format (title, context, decision, status, consequences) lives in the repository next to the code, and its status line marks a decision as superseded when a newer one replaces it (Nygard, 2011).
- "The decision is written down, and the agent built the opposite anyway." Campfyrr. An agent can search Notion, but only if it knows there is something to search for. Campfyrr hands each session the decisions that apply to the area it is about to change, without anyone asking.
The same day, with each
This is a scene, not a customer. Three developers and a product manager are adding team accounts to a product. On Monday the product manager and the CTO decide that invited teammates join on the inviter's plan and are never billed on their own. They write it up properly: a Notion page, a comment on the Linear project, and an ADR in the repository.
With Notion, Linear or ADR files. On Wednesday a developer asks an agent to "add a billing step for new accounts". The agent has the Notion and Linear MCP servers connected. It reads the billing code, sees a clear task and starts. Nothing in the request mentions invites, so it never searches for them. The ADR sits in docs/adr, and the agent never opens that folder. By evening the invite flow asks invited teammates for a card. The product manager finds it in review on Thursday, points to the Notion page, and a developer spends the morning undoing it. Everything was written down. It just wasn't in front of the agent at the moment it mattered.
With Campfyrr. On Monday the same decision is recorded against the accounts and billing area, with its reason and who made it. On Wednesday the agent reads its first billing file, and the hook adds a brief: work in progress there, recent changes, and the decision "invited teammates join on the inviter's plan; never billed on their own". The agent leaves invites out of the billing step and records an assumption about trial accounts, which reaches the product manager as a link. She answers it in one line. Nobody ran a command. See what a session gets.
The difference at the end of the week: one team re-explains a decision it already wrote down; the other spends its time on the next one.
When Notion, Linear or ADR files are the better choice
- Your decisions are for people first. Notion and Linear are where product, design and leadership already read and discuss. Campfyrr records one-line calls with reasons, not long design pages.
- You work in a few clear areas with careful rules. Claude Code can load instructions only when an agent works with matching files, through path-scoped rules and nested
CLAUDE.md files (Claude Code docs). If one person keeps those files current and copies each new decision in, that covers a small team well. - You need the decision in the repository's history. ADR files are reviewed in pull requests and versioned with the code. Campfyrr is a separate record, not a file in your repository.
What it costs
Take 5 developers and 3 business teammates.
- Notion: Plus is about $10 per seat a month billed yearly, so eight seats at $10 is $80 a month. Sources disagree, and one lists $12, which would make it $96 (Breeze, TinyCommand).
- Linear: Basic at $10 per user a month billed yearly, so eight seats at $10 is $80 a month (Linear pricing, read through search results).
- ADR files: free. They live in your repository.
- Campfyrr: five developers at $7 billed yearly is $35 a month ($45 billed monthly). The three business teammates read and answer for free, and everything is free during early access (pricing).
The cost that matters more is upkeep. With Notion, Linear or ADR files, someone has to write the decision up, mark the old one replaced, and copy it into the agents' instructions, or trust each agent to search at the right moment. With Campfyrr, a newer decision replaces the older one automatically and the clash is shown, as in this real example from our own record. Campfyrr doesn't replace your tracker or your documents.
More on where decisions should live, the wider problems of agents ignoring decisions and deciding what to build, and every product here in our research.
Verdict
Choose Notion, Linear or ADR files if your decisions are mainly for people to read and discuss, or a few careful rule files already reach your agents.
Choose Campfyrr if several people run agents on one product, and agents keep building against decisions you already wrote down.
Use both if you want the long write-up where your people read, and the one-line call in front of every agent that touches that area. Keep the Notion page; link it from the reason.
The problem this answers: Agents ignore team decisions: "Agents break team decisions, and CLAUDE.md doesn't help."
The principle behind this: Decide by doing: Our decisions live in what we do, not in what we say.
Move as one at agent speed. Nobody waits. Add Campfyrr to Claude: it briefs every agent before it touches the code, keeps assumptions and handoffs where the team can see them, and never takes your code (what it keeps).