Skip to content
Defer

Your team coordinates.Your agents don't.

Defer makes them work as a team. What one agent figures out, the rest already know. Work hands off with the full thread instead of starting over. And a person stays in the loop on what matters. Across Claude Code, Cursor, and Copilot.

connect your agents

Your agents act on the current decision, not around it.

Every write is judged on the way in, so the decision your agents recall is the current one, not a stale guess. A settled decision stops the next agent before it contradicts the record. When the record meets a genuine contest, Defer holds it for a human instead of guessing.

an example week in a judged record

  1. save · claude-code · tue 14:02

    Use Postgres advisory locks for cron mutual exclusion. The k8s lease approach is overkill at our scale.

    verdict: accept

    A new decision, on the record with author and time.

  2. save · scout · tue 18:40

    Cron jobs need advisory locks so two runs can't overlap.

    verdict: merge

    Same learning from a second seat. Folded into the existing entry, not stored twice.

  3. save · cursor · wed 09:17

    We're on pnpm now. npm workspaces hit the peer-dependency wall.

    verdict: supersede

    Retires the npm-workspaces decision. The trail keeps both, and why.

  4. save · claude-code · wed 11:55

    Use Moment.js for date handling.

    verdict: reject

    Retired in March. The agent gets back what replaced it, not a silent save.

  5. save · cursor · thu 16:08

    Stream agent output over WebSockets.

    verdict: held for review

    It contradicts 'SSE for streaming output' and neither write has the authority to win. Defer holds the contest for a human. Resolved by Ana, thu 17:31: SSE stays.

Nothing is stored silently. Every write returns its verdict, and you can read why anything in the record is true.

Read the teardown: what platform memory does with a conflict it can't decide.

the same example week · friday

Then you ask it.

Anyone can question what your fleet decided. Agents recall before they act. Humans ask in plain language and get the decision back, with the trail that produced it.

  1. ask · alice · fri 09:12

    What's our standard for streaming agent output?

    SSE. A WebSockets write contradicted it thu 16:08, neither side had the authority to win, and Ana resolved it thu 17:31: SSE stays. Both sides are still readable.

  2. recall · claude-code · fri 11:40

    What replaced npm workspaces?

    pnpm, since wed 09:17. The old decision is retired, not deleted: the peer-dependency wall is the recorded reason.

  3. ask · ben · fri 15:03

    What's still open this week?

    Two threads: the advisory-lock rollout checklist (raised tue, no owner yet) and the Temporal sweep over the last Moment call sites (raised wed, Ana owns it).

Answers are half of it. Ana's resolution changed the record's current answer, and the context your agents load at the start of every session carries the current rules: Claude Code, Cursor, Copilot, any MCP client. Monday, every seat reads it before writing a line.

the brief · monday's sessions

+ streaming output: SSE, not WebSockets · resolved by Ana, thu 17:31
read a judged record →

0%

stale decisions leaking back.

Everyone else keeps the latest.
Defer keeps what’s still true.

We replayed a team's decision history through Defer and mem0, the closest memory tool.

Defermem0
the retired standard leaked back0%50 to 90%
retired the old standard10 of 100 of 20

And on merge, accept, and reject calls subtle enough that a recency rule guesses wrong, the judge lands 95%.

And one line in the agent's prompt gets it to check the current decision before it writes: 92% of the time, up from 49% without it. (39-probe harness.)

In-house benchmark, small n, constructed arcs; mem0 2.0.4 self-hosted on local models.

One engine, not just for code. CX, SRE, and finance run the same recall, judge, and gate.

replay the record as of any day →

No one has to remember to write it down.

When a session wraps, Scout can go back through the work your team already finished, bring back what got decided, and write it back through the same judge. Today it reads Claude Code; reading and writing the shared record already works from Cursor, Copilot, and any MCP client, and scouting theirs is on the roadmap.

Scout brings it back. The judge decides.

Two pastes to connect.

add the server

claude mcp add --transport http defer https://mcp.defer.sh/<team>

the rules in your agent's system prompt

This codebase uses Defer (mcp.defer.sh). Call `defer.recall` (set `filters.repo` to the repo you are in) before writing code in any area your team standardizes (libraries, naming, error shapes, tests); the team may have retired the option you would reach for. When a tool response signals contract drift, re-ground with `defer.recall` before trusting a prior answer.

Works in Claude Code, Cursor, VS Code, Codex, and any MCP client.

Personalized per team, including any renamed tools your org composes.

Defer is paid, per team: $500 per team per month, flat, all seats and agents included. We're onboarding design partners by hand right now.

Your team's work writes the record.