Use case

# At hour six, my agent forgets hour one. *Ask it then and get the hour-one answer.*

Follow one workday from hour one to hour six. Recall keeps your morning word for word, and the agent fetches it when it needs it.

[Get started free](https://console.context-mode.com/login) [Read the docs](https://context-mode.com/docs/recall)

One workday

Hour 1 Hour 4 After lunch Hour 6

You set the rules and start the work.

```
you: run the billing tests and fix what fails, keep the refund window at 14 days
you: do not touch the webhook retry code
# the agent runs the tests 30 times; run 3 fails on one line
```

Your client keeps every message. Recall changes nothing yet.

The session reaches your window.

Without Recall

- The client compacts
- Older history becomes a summary
- The failing line from run 3 is gone

With Recall

- Older work goes to the archive, word for word
- The model gets recent work and an index
- Your client's history stays as it is

Recall acts when a request would pass your Active Context. In our 200K test, the session never compacted.

You come back after 2 h. The cache has expired.

```
⚡ context-mode · picked up after a 2 h pause, nothing compacted
```

After a pause the provider writes the whole prompt again anyway, so Recall lays out the short version then.

You ask for the failing line from test run 3.

```
What the model sees: one line of the index
→ Bash "npm test -- src/billing" (context-mode-msg-3f2a…)

What the agent does: fetches run 3 by its id
context-mode-search {"docid": "context-mode-msg-3f2a…"}
```

The run comes back as it was stored. No second test run.

The problem

## Why compaction drops *your early details.*

**Compaction drops details**

Close to the window, your client swaps older history for a summary. Exact lines, early rules and screenshots go first.

**The agent asks again**

After the summary, it no longer sees what you decided. It asks the same question, or runs the tests again to see one line.

**Each request costs more**

Until then, every request sends the whole history again. After a long pause, the provider writes it all to the cache again.

How it works

## How Recall keeps *hour one exact.*

1. 01 **Hour one: you set the rules** "Keep the refund window at 14 days." Your client keeps the full history, as usual.
2. 02 **Hour four: the window is full** Recall moves the morning to the archive, word for word. The model now reads your recent work and a short index of the rest.
3. 03 **Hour six: you ask about the morning** The agent finds test run 3 in the index and fetches it by its id. It does not run the tests again.

Your client keeps every message. Recall changes only what the model gets.

Proof

## At hour six, *the morning is still there.*

**9 of 10** exact answers about early details at the end of the session, against 4 of 10 direct

**0 compactions** through Context Mode. Direct compacted 3 times.

The same 30 steps run twice on a 200K window. For the cost of the same run and the full method, see [Long sessions](https://context-mode.com/solutions/long-sessions) and [Method and sources →](https://context-mode.com/docs/benchmarks#long-session-200k-r2-detail)

Hour one, at hour six

## What your agent still has *at hour six.*

| Detail from the morning | With Recall | After compaction |
| --- | --- | --- |
| Your rule "refund window 14 days" | In the index word for word, listed as a decision not to reopen | In the summary only if it kept it, and reworded |
| "Do not touch the webhook retry code" | In the index word for word | Can get lost with the other early instructions |
| The failing line from test run 3 | The agent fetches the archived run by id | Gone. The agent runs the tests again. |
| The error screenshot | Archived as an image, returned by id | Gone |

An example of the mechanism, not a measurement. [The full table →](https://context-mode.com/docs/recall#before-after)

Products used

## Recall and *Active Context.*

**[Recall](https://context-mode.com/recall)**

Keeps the morning in an archive for 90 days by default, and gives the agent an index to find it.

**[Active Context](https://context-mode.com/active-context)**

Sets the point where Recall acts: the size your session may reach on every machine.

Read more: [Recall docs](https://context-mode.com/docs/recall) · [Active Context docs](https://context-mode.com/docs/active-context) · [All-day sessions without compaction](https://context-mode.com/blog/recall-all-day-sessions-without-compaction)

Related: [Long sessions](https://context-mode.com/solutions/long-sessions) · [For developers](https://context-mode.com/solutions/developers) · [Session resume](https://context-mode.com/session-resume) · [Search](https://context-mode.com/search)

## Ask at hour six. *Get hour one.*

*npx @context-mode/cli* connects your agents. 1,000 requests free, no card.

[Get started free →](https://console.context-mode.com/login) [Read the docs →](https://context-mode.com/docs/recall)