Guide
How rethinker thinks about long coding-agent sessions, what it watches, what it writes, and how to tell whether it is actually saving you money.
How it fits together
Four steps, all inside the way you already work.
Follow the session
Context size, time since the last turn, repeated commands and the shape of your requests.
Speak up at the right moment
When a signal fires, one short message. You stay in control.
Start clean, not empty
Claude writes the handoff note; the next session starts from it.
Count it in money
Cost per task from Claude's usage data, rethinker's overhead included.
In a session
What a working day can look like with rethinker running.
Illustration of a typical day, not a recorded session.
The mental model
Treat context as a running cost, not free memory. Every turn pays to re-read everything that came before. Prompt caching makes that cheaper while the cache is warm and the prefix has not changed; it does nothing once the cache has expired or the prefix changes.
rethinker's job is to notice when the history you are carrying costs more than it is worth, and to make starting over cheap enough that you actually do it.
- Carry history only while it pays for itself.
- Restart on purpose, not by accident. A short note beats a long transcript.
- Judge by money per finished task, not by token counts.
Supported agents
Claude Code is where we build first and where the integration is deepest.
Claude Code
Signals, handoff notes, prompt refinement and the cost view are built for Claude Code first. The cost view reads Claude's own usage data: input, cache writes, cache reads and output.
Codex CLI
rethinker also works with Codex CLI, so teams that use more than one agent can keep one way of working.
GitHub Copilot
rethinker also works with GitHub Copilot, for teams whose editors already run on it.
The signals
Four signals, each with one reason it matters and one concrete suggestion.
The session got heavy
Why it matters: every turn re-sends the whole context, so cost per turn grows with it, and the model has more to sort through.
What you see: a suggestion to hand off once carrying the session costs more than restarting from a note.
You took a break
Why it matters: cached context only lives a few minutes without use. The first turn after a pause writes everything to the cache again, at a premium over plain input.
What you see: a suggestion to hand off before that turn, when a fresh session is cheaper than re-warming the old one.
The agent is stuck
Why it matters: the same command run again and again with no edit in between usually means a dead end, and every retry pays for the full context.
What you see: a prompt to pause and rethink the approach before the next retry.
The ask is fuzzy
Why it matters: vague requests cost extra turns of back-and-forth, and each of those turns re-reads the whole session.
What you see: a clearer version of the request that you can send instead, or ignore.
The handoff note
A handoff note is what the next session needs, not a summary of everything that happened. Claude writes it at the end of a session, and it is short enough to start a new session cheaply.
What it carries
- Goal: what the work is for, in one line.
- Done: what is finished and verified.
- Decisions: what was chosen, and why, so it is not re-litigated.
- Open files: where the work lives right now.
- Next step: the very next action, stated plainly.
What it leaves out
Dead ends that no longer matter, full tool outputs, and anything the code or the git history already records. See an example on How it works.
Prompt refinement
rethinker looks for requests that are likely to cost extra turns: a goal without a definition of done, no pointer to where the work is, or several unrelated tasks in one message. It suggests a clearer version. You decide whether to use it.
The cost view
For each task, rethinker prices Claude's own usage data at published API rates:
rethinker's own Claude calls are included in the same view, so its overhead is never hidden. Savings count only when the same kind of task gets cheaper, not when a prompt gets shorter.
Measure it on your own work
Do not take our word for it. A fair comparison takes three steps:
- Pick a set of comparable tasks from your normal work.
- Run some with rethinker's suggestions and some without, in the same repository and with the same model.
- Compare cost per finished task, including rethinker's own overhead, and check that quality held: tests, review comments, reverts.
Where to look first: long sessions with pauses and repeated reads, because that is where most of the cost sits. Short, single-task sessions have little to save. If nothing was saved, the comparison should say so, and so will we.
What we have and have not measured
rethinker is used by our own team and by a small number of external teams in the private beta. We have not published measured results yet. When we do, they will come with the method, the raw numbers and rethinker's own overhead, including the cases where nothing was saved.
Best practices
Habits that keep long sessions cheap and focused, with or without rethinker.
- 01One task per session.When the task changes, hand off instead of carrying the old history into new work.
- 02Keep the stable prefix stable.Switching models, tools or system instructions in the middle of a session invalidates the prompt cache.
- 03Hand off before a long break, not after it.After the pause, the next turn pays to rebuild the cache.
- 04Let subagents explore.Wide searches in a subagent keep the main session's context small; only the conclusion comes back.
- 05End with an explicit next step.The next session starts faster when the first action is already written down.
- 06Watch cost per task, not tokens per prompt.That is the number your bill is made of.
Privacy and data
rethinker is in private beta. Before general availability we will publish exactly what it reads, what it sends to the Claude API and under whose key, and what, if anything, it sends to us. Private beta teams can ask for these details at info@rethinker.dev.
We help teams work better. We never rank individual engineers by usage.
FAQ
Will rethinker lower my bill?
It targets the moments where most of the cost of long sessions sits, but the honest answer depends on how you work. Measure it per task, in money, including rethinker's own overhead. If nothing was saved, that is the answer.
Doesn't starting a new session throw away useful context?
That is what the handoff note is for. It carries the goal, decisions, open files and next step forward, so the new session starts informed but light.
Does rethinker break prompt caching?
It is designed not to. Suggestions are timed around cache behavior, and a handoff starts a new session from a short, stable prefix.
Which tools does it work with?
Claude Code first. It also works with Codex CLI and GitHub Copilot.
Is legacy modernization available?
Not yet. It is in development, and this guide will cover it when it ships.
How do I get access?
Write to sales@rethinker.dev. We are adding a small number of teams to the private beta. Live demos on request.