It's invisible
Compaction happens between turns, off-screen. You never see what left.
Context window, made visible
Your agent's memory,
something you can see and steer.
An agent's context window is a fixed size. When it fills, something gets silently dropped — and the agent quietly forgets. Accordion turns that black box into a living map you can fold, unfold, and pin. Nothing is ever thrown away.
user text thinking tool call tool result
Today, forgetting is invisible and irreversible.
During a long task the window fills, and something has to go. That removal is invisible and irreversible: old conversation is summarized into a lossy blob or silently dropped. You don't see it happen, and you can't undo it.
It's lossy
A summary throws away detail you may need three steps later.
It's permanent
Once it's gone, there's no expanding it back.
What Accordion is
Context is a view, not a store.
Accordion shows the agent's whole context as a list of sections — one per turn — and treats it as something you resize, not a buffer you flush. Any section can shrink to a short summary and expand back to full detail, instantly, as many times as you like. Folding changes only what the agent is shown, never what is stored — so it's perfectly reversible and provider-safe.
Four actions. Nothing is ever lost.
Full and Folded are the two real states; Pinned is a lock you add on top of Full. Every move is shown and attributed.
Replace a section with its summary to free up room.
Bring a folded section back to full detail. It's live again.
Lock a section open so nothing folds it automatically.
Read a folded section in the window only — the agent's context is untouched.
The distinction that matters most: Unfold and Pin change the agent's context; Peek does not. Peek is for you to look; the rest are for steering.
Automatic mode
The Conductor keeps the window in budget, on its own.
Between every turn it reads what the agent is doing, folds the sections that have gone cold, and unfolds the ones becoming relevant again. The further back something is, the more coarsely it's summarized; the closer it is, the more detail it keeps. It never pins — a pin exists precisely to overrule it.
- Folds cold context the moment the budget tightens.
- Unfolds what's becoming relevant again, automatically.
- Every move is attributed and replayable — automation you can watch.
budget
The protected working tail
Recent reasoning stays intact. Always.
The newest stretch of the conversation — the agent's latest reasoning, the tool results it just saw — is its working memory. Accordion reserves the newest ~20k tokens (configurable) and never folds them. The guarantee is token-based, not turn-based: it always covers a real, recent slice. This protection is absolute.
Three parties operate the same accordion.
Not all of them can do everything — by design. You can do it all. The agent can reach for what it needs but never decides what to discard. The Conductor automates, but never pins.
| Action | You | The agent | The Conductor |
|---|---|---|---|
| Fold | ✓ | — | ✓ |
| Unfold | ✓ | ✓ | ✓ |
| Pin | ✓ | ✓ | — |
| Peek | ✓ | — | — |
Your agent's memory, visible and reversible.
Your agent's memory should be something you can see and steer — not a black box that silently forgets. Open the window when you want to watch; close it and let the Conductor run.
Also for Linux · source on GitHub · free & open source