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, working from one playbook.

Your agents recall the current decision before they act, and save what they learn. The judge decides what enters the playbook: accept, merge, supersede, or reject, with the trail kept. And when a call genuinely needs a human, Defer escalates instead of guessing.

an example week in a judged playbook

  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 playbook 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 playbook's current answer, and the brief 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 playbook →

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%.

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

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 playbook may have retired the option you would reach for. Call `defer.brief` at the start of each session and again whenever a tool response signals contract drift.

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.

Write hello@defer.sh →read a judged playbook →
Already onboarded? Sign in.

Your team's work writes the playbook.