Guides / Use cases

Coding agents

For developers who want Claude Code, Codex or an agent of their own to remember how they work, what a repository's rules are and what was decided last month. Install an integration in a few minutes, or add memory to your own agent with the SDK.

What memory adds

Without memory, every coding session starts from the same blank page and you repeat your preferences in each one. With it, the agent starts where the last session ended:

Recall is memory, not the agent. It does not read your repository, index files or run tools; it stores what you and the agent said and learns from it. Code search stays with your agent.

How to model it

The integrations below set this up for you. When you build your own agent, map it like this:

Build it

Claude Code, Codex and other agents

Each integration recalls (adds your peer card and the facts Recall learned about you to the agent's context), records (stores your prompts and the agent's final replies) and, where the agent supports it, adds Recall's MCP tools so the agent can look things up and correct memory. The agent is a peer Recall does not observe (claude, codex), so facts are learned about you.

Claude Code. Install the plugin, and enter your API key when Claude Code asks for it (it is kept in your system's credential store):

/plugin marketplace add recallmem/recall-plugin
/plugin install recall-memory@recall

Set the workspace and your peer id under /plugin → recall-memory → Configure, or with RECALL_WORKSPACE_ID and RECALL_PEER_ID. Then run /recall-memory:status to check the connection. Each Claude session is recorded in a Recall session named cc-<session id>.

Codex. codex plugin marketplace add recallmem/recall-plugin and codex plugin add recall-memory@recall, or the installer; pick one, because both together handle every turn twice. Codex skips new hooks until you trust them, so run /hooks once. The key comes from RECALL_API_KEY or ~/.recall/config.json (see connect to your server).

A team on the integrations. Everyone uses the same workspace and their own stable peer id. Each developer's memory is their own; rules they ask the agent to remember are saved as facts about them. For rules the whole team shares, write them to a repository peer as shown below.

Any MCP client. Point it at https://api.recallmem.dev/mcp. Cursor, VS Code and Claude Code (claude mcp add --transport http recall https://api.recallmem.dev/mcp, then /mcp → Authenticate) sign in with your email; no key is copied. Through MCP the model decides when to look things up. With Remember automatically on (the default for a connected app; change it under API keys → Connected apps) it also saves lasting facts you share without being asked. See Add Recall as a connector.

Your own agent

Install the SDK (npm install @recall-memory/sdk or pip install recall-mem) and set RECALL_API_KEY. Create the peers and a session per coding session. Set observeMe: false before the agent's first message is stored.

import { Recall } from "@recall-memory/sdk";

const recall = new Recall({ workspaceId: "acme-eng" });

const dev = recall.peer("dev-4821");
// Recall learns about the developer, not from the agent's own replies.
const agent = recall.peer("coding-agent");
await agent.setConfiguration({ observeMe: false });
// The repository's rules live on a peer of their own. Nobody speaks as it.
const repo = recall.peer("repo-billing-api");
await repo.setConfiguration({ observeMe: false });

// One session per coding session, filed under the repository's scope.
const session = recall.session("cs-20261010-7f2c", {
  peers: [dev, agent],
  scopes: ["billing-api"],
});

import re

from recall_memory import PeerConfig, Recall

recall = Recall(workspace_id="acme-eng")

dev = recall.peer("dev-4821")
# Recall learns about the developer, not from the agent's own replies.
agent = recall.peer("coding-agent")
agent.set_configuration(PeerConfig(observe_me=False))
# The repository's rules live on a peer of their own. Nobody speaks as it.
repo = recall.peer("repo-billing-api")
repo.set_configuration(PeerConfig(observe_me=False))

# One session per coding session, filed under the repository's scope.
session = recall.session("cs-20261010-7f2c", peers=[dev, agent], scopes=["billing-api"])

Rules you know for sure: write them. Conclusions are facts you state directly. They are searchable at once, without waiting for background learning, and every developer's agent reads the same ones.

// Rules the team states outright: write them as facts, so they hold from the first session.
await repo.conclusions.create([
  "Migrations are generated with `pnpm db:generate`; never edit them by hand.",
  "billing-api runs on Node 22 and uses pnpm, not npm.",
  "Money amounts are integers in cents; never floats.",
]);

# Rules the team states outright: write them as facts, so they hold from the first session.
team_rules = [
    "Migrations are generated with `pnpm db:generate`; never edit them by hand.",
    "billing-api runs on Node 22 and uses pnpm, not npm.",
    "Money amounts are integers in cents; never floats.",
]
repo.conclusions.create([{"content": rule} for rule in team_rules])

Session start: read, focused on the task. searchQuery pulls the facts that matter for this task into the prompt instead of the most frequent ones. Both are reads, not questions: no answer is generated, so they are fast and included in the price. Run them in parallel.

// At session start: what is known about the developer and the rules that touch the task.
// Two reads: no answer is generated, so they are fast and included in the price.
const task = "Add a refund_reason column to the payments table";
const [ctx, rules] = await Promise.all([
  session.context({ peerTarget: dev, searchQuery: task, tokens: 1500 }),
  repo.context({ searchQuery: task }),
]);
const messages = [
  { role: "system", content: `Rules of this repository:\n${rules.representation ?? ""}` },
  ...ctx.toOpenAI(agent),
];

# At session start: what is known about the developer and the rules that touch the task.
# Two reads: no answer is generated, so they are fast and included in the price.
task = "Add a refund_reason column to the payments table"
ctx = session.context(peer_target=dev, search_query=task, tokens=1500)
rules = repo.context(search_query=task)
messages = [
    {"role": "system", "content": f"Rules of this repository:\n{rules.representation or ''}"},
    *ctx.to_openai(assistant=agent),
]

After each turn: record the conversation, not the work. The developer's prompt and the agent's final answer are what Recall learns from. Build logs, diffs and file contents cost tokens and teach it nothing about the developer, and they are where secrets hide.

// After each turn: the developer's prompt and the agent's final answer. No tool output, no file
// contents, no secrets (this pattern is crude: run your own secret scanner too).
const redact = (text: string) =>
  text.replace(/\b(?:sk|pk|ghp|xox[bp])[-_][\w-]{16,}/g, "[redacted]").slice(0, 24_000);
const prompt = "Add refund_reason to payments. Nullable for now, we backfill next sprint.";
// Your model wrote this answer from `messages`.
const answer = "Added a nullable refund_reason column and generated migration 0042.";
await session.addMessages([dev.message(redact(prompt)), agent.message(redact(answer))]);

# After each turn: the developer's prompt and the agent's final answer. No tool output, no file
# contents, no secrets (this pattern is crude: run your own secret scanner too).
def redact(text: str) -> str:
    return re.sub(r"\b(?:sk|pk|ghp|xox[bp])[-_][\w-]{16,}", "[redacted]", text)[:24_000]

prompt = "Add refund_reason to payments. Nullable for now, we backfill next sprint."
# Your model wrote this answer from `messages`.
answer = "Added a nullable refund_reason column and generated migration 0042."
session.add_messages([dev.message(redact(prompt)), agent.message(redact(answer))])

Past decisions: ask the repository. A question with scope reads only the sessions filed under that repository. It is one model call of a few seconds, so ask when the agent needs it, not on every turn.

// Weeks later, from any session: what was decided in this repository? Only sessions in its
// scope are read. (waitForIdle is for this demo; an agent rarely blocks on learning.)
await recall.waitForIdle();
const decided = await recall.chat("Is refund_reason nullable, and why?", {
  scope: "billing-api",
  reasoningLevel: "low",
});

# Weeks later, from any session: what was decided in this repository? Only sessions in its
# scope are read. (wait_for_idle is for this demo; an agent rarely blocks on learning.)
recall.wait_for_idle()
decided = recall.chat(
    "Is refund_reason nullable, and why?", scope="billing-api", reasoning_level="low"
)

Rules change, people leave.

// A rule that changed: delete the old fact and write the new one.
const stale: string[] = [];
for await (const rule of await repo.conclusions.list()) {
  if (rule.content.includes("Node 22")) stale.push(rule.id);
}
for (const id of stale) await repo.conclusions.delete(id);
await repo.conclusions.create("billing-api runs on Node 24 and uses pnpm, not npm.");
// A developer who leaves: erase them and everything learned from or about them.
await dev.delete();

# A rule that changed: delete the old fact and write the new one.
stale = [rule.id for rule in repo.conclusions.list() if "Node 22" in rule.content]
for rule_id in stale:
    repo.conclusions.delete(rule_id)
repo.conclusions.create([{"content": "billing-api runs on Node 24 and uses pnpm, not npm."}])
# A developer who leaves: erase them and everything learned from or about them.
dev.delete()

Settings that matter

Cost and speed

Measured from Europe against the hosted API (Frankfurt), October 2026: a context read took 0.3 to 0.7 seconds, so memory at session start adds well under a second. A question at low took 2 to 4.5 seconds. Learning runs in the background and never holds up a turn.

Context, search and storage are included. You pay for learning, $1.75 per million message tokens with every message counting as at least 50, and for questions. A developer who works 20 days a month, with 30 prompts a day of about 100 tokens, the agent's 30 replies (long, but read only as context, at most 200 tokens each), and 40 questions about past decisions:

A pasted stack trace counts at its length: 2,000 tokens cost $0.0035. More in Cost and speed.

Privacy and forgetting

Prompts carry more than preferences: pasted errors with connection strings, customer data from a bug report, code under NDA. Tell your team what the agent records, switch recording off for repositories that must not leave your machines, and never record tool output or file contents from your own agent. Recall stores data in Frankfurt; text is processed by AI model providers in the US through OpenRouter, restricted to providers that do not collect it, and is never used to train models. If you work on client code, check that your contract allows a processor; see the DPA.

To remove one wrong or outdated fact, ask the agent to forget it (the MCP tools include delete_conclusion) or delete it by id. When a developer leaves, dev.delete() erases their messages and every fact about them or from their view; facts about other peers that merely mention them stay. See Forget a person, Export your data and Privacy, consent and forgetting.

Pitfalls

• Secrets in prompts. A pasted .env or token is recorded with the prompt. Redact before you record, and use RECALL_RECORD=false for repositories you cannot risk.
• One workspace for several clients. What the agent learned in one client's code then surfaces in another's. Use a workspace per client, each with its own key.
• Team rules said only in passing. A rule mentioned once in a chat is learned as a fact about the developer who said it. Write rules the whole team follows to the repository's peer.
• Recording tool output. Logs and file dumps cost tokens and teach nothing about how anyone works. Record the prompt and the final answer.
• Both Codex routes installed. The plugin and the installer each handle every turn, so everything is recorded twice. Pick one.
• Expecting it to know the code. Recall remembers conversations, not files. The agent still needs its own code search.

Next: Multi-agent systems · Reasoning levels and models