Six members of a software team reviewing an architecture decision together at a whiteboard

Use case: a software team where architecture decisions stop getting lost

6 min read

A simulated scenario: six people on Claude Code and Cursor, architecture decisions that get lost, and a shared memory over MCP, with illustrative numbers.

by Equipo MemoryFirst

Table of contents
  1. The week three agents wrote three different retry strategies
  2. What it costs, with illustrative numbers
  3. How the team is set up
  4. One day later, in the scenario
  5. What is free, what is Pro, and where Team fits
  6. Limits worth knowing
  7. Who it is for and who it is not for

Simulated scenario. Taller Norte is a fictional six-person company building a B2B logistics platform. Everything below is an illustrative example: the people, the company and the numbers are made up, and none of it is a measured result or a real customer. What is real is what the product does, and we checked that against our own technical documentation.

The week three agents wrote three different retry strategies

Marta owns the backend and works with Claude Code. Iván builds the shipment worker with Cursor. Lucía works on the mobile client, also with an agent. In March the team decided, in a twenty-minute meeting, that calls to carriers would be retried idempotently with exponential backoff, and that they would not add a queue broker: they would use Postgres tables.

In May, Iván asked his agent to add retries to the worker. The agent knew nothing about March. It proposed a message broker, the most reasonable choice if you lack the context. Iván accepted. A week later Lucía fixed a network failure in the client with her own retry loop, with no backoff. And Marta, reviewing, needed a whole afternoon to work out why three different approaches coexisted.

Nobody did anything wrong. The decision lived in two people's heads and in a chat thread from two months earlier. Coding agents start every session cold, and a team of six multiplies that by six.

Two developers reviewing a bug while one of them tries to remember why something was decided

What it costs, with illustrative numbers

For the scenario we assume the following, all invented but plausible:

ItemBeforeAfter
Minutes per session re-explaining context to an agent82
Agent sessions per person per day44
Architecture decisions reopened by mistake in a quarter51
Review hours spent on contradictory decisions in a quarter226

With six people, four sessions a day and six minutes saved per session, that is about 2.4 team-hours a day that used to go on re-explaining. This is a back-of-the-envelope calculation on assumed data: your team may have half or triple. The useful part of the exercise is that it pushes you to measure your own numbers for two weeks before deciding anything.

How the team is set up

The setup is short and uses pieces that exist today.

  1. One shared memory over MCP. Each person connects their client (Claude Code, Cursor, VS Code or ChatGPT) to MemoryFirst's remote MCP server. Everyone writes to the same memory and every event is signed with who wrote it and through which AI. In the dashboard, the team's workspace shows who has written today and how many events each person has.
  2. Hooks in Claude Code. When a session starts, the hook asks the memory for a project briefing (up to about 2,500 tokens) and injects it as context. When the session ends, the transcript is ingested in the background. The project is identified by the folder name.
  3. Rules in Cursor. Cursor does not have those hooks: it connects over MCP and the agent uses the mf_recall, mf_query and mf_record tools when the project instructions tell it to. It is less automatic, and that is worth saying.
  4. A team norm for writing. One event per decision, not per step. Record at the moment it happens: a non-obvious decision, a real blocker, an important deploy. Importance 3 for business, customers or production incidents, 2 for relevant technical decisions.

March's decision, recorded this way, would look like this: type decision, title "Idempotent retries with exponential backoff, Postgres queues, no broker", importance 2, and the why in the body. When May refines it, a new event is recorded that supersedes the old one: the old one stops feeding recall but is not deleted.

A small team in a standing morning meeting

One day later, in the scenario

Iván opens a session and asks his agent for retries on the worker. Before proposing anything, the agent queries the memory with mf_query ("what did we decide about retries and queues?") and gets March's decision with its citation: who recorded it, when, and with which AI. It proposes Postgres tables with exponential backoff. The next day Lucía sees the same context when she opens her session.

On top of that, the team's morning brief summarises what moved since the last one: new decisions, open blockers. Small teams value this part most, because it replaces half a sync meeting.

What is free, what is Pro, and where Team fits

  • Free: one project, MCP memory with Claude Code hooks, 30-day retention and one seat. Enough for one person to try the whole flow.
  • Pro: €12 a month billed annually (€144 a year), or €14.40 month to month. Unlimited projects, unlimited retention and all connectors, but one seat.
  • Team: €39 a month billed annually (€468 a year), five seats, shared team memory and a librarian queue. Each seat beyond five costs €9 a month billed annually (€108 a year) or €10.80 month to month; a team of six, like the one in the scenario, adds one.

Prices include VAT and come from our pricing page as of 2026-11-14. Check the plans in case they have changed.

Limits worth knowing

  • Memory depends on someone writing. If the team does not record decisions, there is nothing to recall. The hooks capture transcripts, but a clear decision in its own event is recovered better than one buried in a two-hour conversation.
  • The agent may not look. In Cursor especially, it depends on the instructions asking for it and on the model following them.
  • Isolation between workspaces. Each workspace's data is separated by tenant filters and, optionally, by database-level row security. There is no separate physical database per customer. For an internal team that is reasonable; if you need more, read memory you can audit.
  • Where it is processed. The database, embeddings and original files are in the EU. By default, the question and the retrieved passages are sent to an inference provider in the US to write the answer; you can bring your own key. There is no self-hosted edition.

Who it is for and who it is not for

It is for teams of 3 to 15 people with coding agents in daily use, where decisions are made fast and documented little. It is not for anyone looking for a documentation tool (humans write elsewhere, the AI reads here), nor a replacement for the ADRs in your repository: it complements them.

If you want the mechanism first, start with memory for Claude Code and coding agents and why AI agents start cold every session. To connect your client, see plug memory into any agent over MCP. And if you are comparing options, the 2026 market map sorts them by category.

A developer working with focus, a notebook open beside her

Try shared memory with your team

Start free with one project and move to Team when several people need to write to the same memory.

Start free

Keep reading