# Keep your agents working beyond the context window

**Status:** Live beta.

CtrlB Recall

CtrlB Recall keeps commands, errors, decisions and tool results searchable across sessions. Your agents find the context they need to continue long tasks, even after compaction.

- 81 to 94%: Detail questions right with CtrlB Recall
- 22 to 35%: Right with the compaction summary only
- 0 model calls: To build memory. Searchable in 5.5 s
- 1.4 s vs 189 s: Search at 100× the record, against grep

## Recover what happened, not just the summary

After compaction

A compaction summary keeps the outcome. CtrlB Recall keeps the steps that led to it.

Illustrative example:

**After compaction:** “The previous test failed.”

The summary keeps the outcome. The command, the error and the fix are gone.

Kept: 1 line

**With CtrlB Recall:** Find the command, error and change from the previous test failure.

| Detail | Original record |
|---|---|
| Command | `pytest tests/auth/test_token.py -x` |
| Error | `FAILED test_refresh: expected 401, got 200` |
| Change | `auth/token.py: check expiry first` |

Source: session 7f3a2c, rows 4,182 to 4,190

Memory that decides when it writes has to guess which details will matter. CtrlB Recall keeps every row, so the agent decides at read time, when it knows the question.

## How CtrlB Recall works

Three steps, and your agent runs all of them through hooks and tools.

1. **Capture:** Save messages, tool calls and results from connected agent sessions.
2. **Keep:** Keep the original record while the agent's context is compacted.
3. **Recall:** Find earlier commands, errors and decisions through the agent's tools.

Illustrative flow:

1. Your agent: Claude Code or Codex runs as usual. Subagents too.
2. Hooks upload: At the end of each turn, before compaction and at session end. Secrets are redacted first.
3. Your bucket: One row per message, tool call and tool result. Open Parquet in S3, GCS or Azure Blob.
4. Recall tools: The agent searches the record over MCP.

At session start, the plugin adds one line to the agent's context: search the record before you answer about earlier work. Without that line, GPT-6 Luna made no recall call in 90% of runs. Hooks redact text that looks like a secret before upload, but the patterns are not a guarantee.

## What your agents can ask

Four MCP tools read the record, and each reply stops at 12,000 characters.

- **Find a word across sessions** (`search_sessions`): It finds a whole word in messages, commands and results, in current and past sessions. It returns 10 hits by default, 25 at most. Example: `search_sessions(term="refunds.py")`. You get: Hits with session, row number and a 300-character snippet.
- **Find a command you ran before** (`find_command`): It returns every past tool call whose command contains your text, newest first. It returns 10 by default, 25 at most. Example: `find_command(command="pytest tests/refunds")`. You get: The total, then session, row and command for each match.
- **See what happened next** (`next_actions`): It returns the result of one tool call, then the next three calls and their results. Text and thinking rows are skipped. Example: `next_actions(session_id="7f3a91c2", seq=41)`. You get: What the agent did after a failure, and whether it worked.
- **Open the rows around a hit** (`fetch_records`): It returns the rows of a range in order. A range holds 50 rows at most, and each body is cut at 4,000 characters. Example: `fetch_records(session_id="7f3a91c2", seq_from=38, seq_to=42)`. You get: The exact rows, with the full length of any cut body.

## Recover more details after compaction

Four models, two families, asked at real compaction points.

Four engineers' sessions, 100 detail questions per model, with a one-line instruction to search.

| Model | Summary only | CtrlB Recall |
|---|---|---|
| Claude Haiku 5.5 | 23% | 85% |
| Claude Sonnet 5.5 | 22% | 89% |
| GPT-6 Luna | 29% | 81% |
| GPT-6.1 Sol | 35% | 94% |

Detail questions right: summary only against CtrlB Recall.

Internal evaluation. Four models in two families, 100 detail questions per model, one run per question. The summary stays in context in both arms. The Recall arm also has the full session record and a one-line instruction to search earlier work.

### Better recall doesn't always need a bigger model

Claude Haiku with CtrlB Recall answered more than Claude Sonnet with only the summary.

| Model size | Setup | Correct answers |
|---|---|---|
| Larger model | Sonnet 5.5, summary only | 22% |
| Smaller model | Haiku 5.5 + CtrlB Recall | 85% |
| For reference | Sonnet 5.5 + CtrlB Recall | 89% |

Same 100 detail questions. Haiku 5.5 with Recall costs about 1/15 as much per question as Sonnet 5.5.

- 70 to 72%: Cross-session lookup with CtrlB Recall, small models. Summary only answered none. 60 questions per family, no session named.
- -2 to +6 pts: Recall change when the summary is dropped, with CtrlB Recall and the search instruction on. Each answer cost less. Compaction pauses a Claude Code session for a median of 61 s.

With CtrlB Recall on both sides, the larger model is level or ahead. Haiku 5.5 trails Sonnet 5.5 by 4 points, not significant. GPT-6 Luna trails GPT-6.1 Sol by 13.

The limit: four engineers at one company over six weeks, and a model judged the answers.

Search matches exact words. We did not test search by meaning.

## How CtrlB Recall compares with Mem0

Compared with extracted memory

Mem0 keeps short extracted memories. CtrlB Recall keeps the full record and searches it.

Illustrative example: Which test failed before the fix?

| | Compaction summary | Extracted memory | CtrlB Recall |
|---|---|---|---|
| Decides | At compaction | When it writes | When your agent asks |
| Detail recall | 29% | 37% | 81% |

One model (GPT-6 Luna) and the same 100 detail questions for all three, asked at real compaction points.

| Comparison | Mem0 | CtrlB Recall |
|---|---|---|
| Accuracy: detail questions answered | 37 to 44% | 81 to 94% |
| Model calls to build memory | 632 ($3.92) | 0 ($0) |
| Time until searchable | 3.6 h | 5.5 s |

Internal evaluation against open-source Mem0 2.2.1. Accuracy: GPT-6 Luna and GPT-6.1 Sol, 100 detail questions each (Mem0 was not run with Claude). Build: one engineer's 538 Claude Code sessions. Cost per question answered was the same, $0.003.

## Find answers across your team's agent sessions

Recover past investigations, commands and fixes without knowing which session holds them.

- Which command fixed this error?
- Why did we change this configuration?
- What did the other agent already try?

Search the sessions you're authorized to access.

- You see your own sessions by default. The `sessions.read_all` permission shows everyone's.
- Rows are open Parquet files in your S3, GCS or Azure Blob bucket.
- Search stays fast as the record grows.

| Record size | CtrlB | grep over files |
|---|---|---|
| 1× (170k rows) | 147 ms | 450 ms |
| 10× (1.7M rows) | 494 ms | 4.1 s |
| 100× (17M rows) | 1.05 s | 165 to 408 s (9 of 120 calls finished) |

Median search time, 120 calls. At 100×, the files are larger than the test machine's memory, and grep finished 9 of 120 calls. On those nine calls, CtrlB took 1.4 s and grep took 189 s.

## Works with your agents and Relay

The CtrlB plugin connects Claude Code and Codex.

### Relay runs on CtrlB Recall

Relay builds its runs from Recall records. Recall also works on its own, with no Relay.

[See CtrlB Relay](https://ctrlb.ai/relay)

## Your agent history, in your own cloud

CtrlB Recall stores session records in your own bucket as open Parquet. Connect your agents through integrations, MCP or the API.

## Start with the agents you run today.

AI Observability pricing

Tracing, evaluations, investigations, and Guardrails in one plan.

- Production traces and model cost tracking
- Scheduled investigations and prompt comparisons
- Tool policies with Guardrails
- OpenTelemetry, your own bucket and your own model key

**From $499 / month.** Platform fee. Usage is quoted separately for your workload. We agree usage costs before you start. Your providers bill model and bucket costs directly. Larger deployments: enterprise pricing.

## Common questions

FAQ

### What does CtrlB Recall keep?

It keeps one row for each message, tool call and tool result. Each row has the role, the shell command, the time and the session. Subagents are included. Nothing is updated or deleted.

### How is it different from extracted memory?

Extracted memory decides what to keep when it writes. CtrlB Recall keeps every row, and your agent decides what matters when it asks. With GPT-6 Luna on 100 detail questions, extracted memory scored 37% and Recall scored 81%. Against open-source Mem0 2.2.1, Recall answered 81 to 94% of detail questions and Mem0 answered 37 to 44%.

### How is it different from compaction?

Compaction writes a summary and drops the rows. In our Claude Code sessions, 6% of exact answers were still in the context after compaction. Exact means a path, number, error line or command. Recall keeps the rows, so the agent can find them.

### Where does my data live?

Rows are open Parquet files in your S3, GCS or Azure Blob bucket, and SQL can query them. Hooks redact text that looks like a secret before upload. The redaction patterns match common key and token shapes and are not a guarantee.

### Who can see whose sessions?

You see your own sessions by default. The sessions.read_all permission shows every user's sessions. The sessions.write permission lets your agents upload them.

### What does it cost, and how fast is it?

At 100× the record, CtrlB search took a median of 1.05 s. Grep over the files finished 9 of 120 calls. Haiku 5.5 with Recall costs about 1/15 as much per question as Sonnet 5.5. Pricing is on this page.

### Do I need Relay?

No. CtrlB Recall works on its own. Relay builds its runs from Recall records, so agents in a Relay run need sessions.write.

### Which agents does it work with?

Claude Code and Codex, through the CtrlB plugin and hooks. The hooks upload at the end of each turn, before compaction and at session end.

## See CtrlB Recall with your agents

Live beta. From $499/month, plus usage.

## Metadata

- **Canonical HTML**: https://ctrlb.ai/recall
- **Last updated**: 2026-11-07

## Related

- [AI Observability](https://ctrlb.ai/ai-observability): Trace agent runs, find failures, and test changes.
- [Self-Improving Agents](https://ctrlb.ai/ai-observability/self-improving-agents): Turn failed runs into proposed prompt and skill changes.
- [Evaluations](https://ctrlb.ai/ai-observability/evaluations): Save failures as tests. Compare versions before release.
- [Guardrails](https://ctrlb.ai/ai-observability/guardrails): Block, approve or mask tool calls and results.
- [CtrlB Relay](https://ctrlb.ai/relay): Claim work, share findings and continue across sessions.

## Links

- [Book a demo](https://ctrlb.ai/contact?source=demo-recall)
- [AI Observability pricing](https://ctrlb.ai/ai-observability#pricing)
- [Documentation](https://docs.ctrlb.ai/)