rethinker
TR Request access
Private beta · now adding teams →

Know when to hand off. Know what each task cost.

rethinker runs alongside Claude Code. It flags the moment when carrying the session history stops paying off, writes a short handoff note so a fresh session starts light, and prices every task from Claude's own usage data.

Request access → How it works
  • Claude Code · primary
  • Codex CLI
  • GitHub Copilot
6+ external teamsin private beta
Building since 2025first product in the hands of teams
Bootstrappedindependent, no outside investors
Based in Türkiyeworking with teams anywhere

What ships today

Three things rethinker does inside the way you already work with Claude Code. Also works with Codex CLI and GitHub Copilot.

signals

Hear about it the moment it matters.

rethinker watches context size, time since the last turn and repeated commands, and says one short thing when a signal fires. Suggestions are timed around prompt-cache behavior, so stable prefixes stay cacheable instead of being broken.

Large contextevery turn re-reads all of it
Cold cachethe next turn re-writes the whole context
Runaway loopsame command, no edit in between
Unclear prompta clearer version of the ask
handoff note

Start the next session light, not empty.

When carrying the history stops paying off, Claude writes a short note: goal, done, decisions, open files, next step. The fresh session starts from that note instead of the whole transcript.

cost view

See what each task cost, in money.

Every task is priced from Claude's own usage data, split into input, cache writes, cache reads and output, at published API rates. rethinker's own Claude calls are counted in the same view, so its overhead is never hidden.

Where it helps

Teams that already run coding agents on real work and can feel where the cost goes.

long refactors

Long refactors

Hours in a large codebase, with the context growing on every file read.

rethinker suggests a handoff when carrying it stops paying off; the note keeps the thread.

debugging detours

Debugging detours

A detour fills the session with dead ends that no longer matter.

A fresh session starts from what was decided, not from the whole trail.

usage-based billing

Teams watching AI spend

Re-read context is the line item that keeps growing.

Cost per task, with cache writes and cache reads shown separately.

legacy · next

Legacy modernization

Old systems that need to move slice by slice, with engineers in control.

In development. See the roadmap →

Read the full guide →

What's next

The same discipline, small steps, clear handoffs, honest measurement, applied to the rewrites nobody wants to start.

in development

Legacy modernization, slice by slice

Claude agents map an old application, split the work into small slices and draft each one. Engineers review and own every change.

Roadmap →

  • An inventory graph of the legacy app: screens, endpoints, data, dependencies
  • Small slices, each with acceptance criteria and a rollback plan
  • Claude agents do the migration work; engineers review and own every change
  • One progress metric everyone can read: how much has really moved

Principles

What you can expect from us.

  1. 01
    Measured in money, not token counts.Shorter prompts are not always cheaper: cache writes and reads change the math. When we report savings, we report them in money, including our own overhead, or say plainly that nothing was saved.
  2. 02
    Your code stays yours.What rethinker reads and what it sends is documented for beta teams on request. See Security & data.
  3. 03
    Small, reversible steps.Modernization work is designed as small slices, each with acceptance criteria and a rollback plan. No big-bang rewrites.
  4. 04
    Teams, not leaderboards.We help engineers work better. We never rank individuals by usage.

Running long Claude Code sessions? Let's look at one together.

Write to sales@rethinker.dev with your team size and the agents you use.

Request access → Read the guide