Intercept
The plan stops before the code.
When your agent finishes planning, Redline catches the plan and holds the session open while you read.
Redline Meta-Harness
Code review
for your agent’s plan.
Catch the mistake in the plan, not the pull request. Redline intercepts the plan from your coding agent, opens it as a document with tracked changes and line comments, and holds the agent until you approve.
- Release
- v0.1 · early release
- Runs on
- macOS 11 or later
- Works with
- Claude Code · Codex · Cursor · Antigravity (preview)
- License
- Apache-2.0
How it works
Redline the plan, not the code.
The round trip between your coding agent and the document, one step per scroll.
Redline
Mark it up in place.
Edit the text and every change is tracked. Pin questions and feedback to the line they’re about.
Send
Ask, or revise.
Questions come back answered with the plan unchanged. Edits come back as a new revision.
Resolve
Every comment gets an answer.
Each comment returns with a resolution to accept or reopen. Approve when it’s right, and build.
v1
Rate-limit the public API
Protect the API from bursts without breaking well-behaved clients.
Limits
Count requests per IP address, in a one-minute sliding window.
Responses
Over the limit, return 429 with a Retry-After header.
user ~ % claude› Plan rate limiting for the public API── plan intercepted by redline ──no pending comments
Discussion
Every comment opens a colleague.
Click Discuss on any comment and Redline forks the session that wrote the plan. The fork knows everything the planner knew — the code it read, the reasons it had — and talks it through with you while the original agent waits, untouched.
- It does the homework. It reads the repo, searches the web and checks what you’ve decided before, then answers about the paragraph you commented on.
- It draws. Replies render flowcharts, sequence diagrams, tables, code and callouts, not a wall of text.
- Report or conversation. Get a structured answer, or flip the thread into a back-and-forth with an engineer who has opinions.
- Talk, then decide. When the discussion lands somewhere, make it a change and it goes back with your markup.
Claude Code and Codex fork their own sessions; Cursor and Antigravity plans get a Claude sidecar seeded with the plan. Forks are read-only — they never edit files or touch the held session.
QUESTION§responses:p0c-002
Teams behind one shared key will hit this fast. Per-seat limits?
Discuss with ClaudeDefault (CLI default) ▾
forked from the plan session · read-only
How would per-seat limits sit on top of the token bucket? Sketch it.
One bucket per seat, with the key’s bucket as a ceiling — a heavy user can’t starve the rest of the team, and the key still has a hard limit.
| per key | per seat + ceiling | |
|---|---|---|
| fairness | one seat can starve the team | each seat has its own budget |
| redis keys | 1 per key | 1 per seat + 1 per key |
Grounded in src/middleware/rateLimit.ts and v1 of your plan.
I’d go per seat with the key as a ceiling — otherwise one noisy seat still takes the whole team down. The catch is Redis: that’s a key per seat. Worth it, I think. Want the key layout next?
Make this a changeReply…
The browser
Walk your whole app. Hand over one list.
Open your dev server in Redline’s browser and click through it like a tester. Highlight anything, say what’s wrong, and it lands in the Cart — filed under the page you were on, with a pointer to the exact component. Twenty pages, forty pages: the list keeps the map. Then open it in the Prompt Drafter, add the context only you have, and send it.
HireboardJobsApplicationsSettings
Staff Frontend Engineer, Design Sys…Remote · $210k
Senior Platform EngineerNYC · $190k
Data EngineerRemote · $170k
Pointers, not paraphrase.
The location is read off the element you highlighted — “Apply button”, “Job card title” — and a background agent sharpens the name. You only write the problem.
A map of the walk.
Notes group by page in the order you visited, and coming back to a page adds to its section instead of starting another.
An agent on every page.
Every tab has its own agent that reads and drives the page. Ask it about any note and it can read the repo for the answer.
The workspace
Everything around the plan, in one window.
Running
hireboard-webNext.js
localhost:3000Stophireboard-apiNode
localhost:8080StopRecently run
docs-siteAstro
localhost:4321Run ▶adminVite
localhost:5173Run ▶Every dev server, one screen.
Localhost finds the servers you have running and the project each one came from. Stop one, open it, or bring back a recent one with a click — no cd, no npm run dev.
~/web~/api~/docs~/infra~/web~/api~/docs~/infra~/web~/api~/docs~/infra
A dozen terminals, tiled.
Real shells, side by side — up to fourteen tiles — with the file tree and the plan next to them.
v3 restored
~/web % claude --resume 4f2a…2 unsent comments carried over
Pick up where it stopped.
Closed the terminal or restarted the Mac? Restore the plan session and Redline resumes the agent, re-opens the plan and carries your unsent comments onto it.
v1v2v3v4
Export MarkdownExport DOCX
Every version, kept.
Browse each revision of a plan, restore an earlier one, and export any of them.
- const key = req.ip+ const key = req.apiKey ?? req.ipAI pre-review · consider per-seat keysReview the code, too.
Annotate the diff line by line, get an AI pre-review as draft comments, and commit or push to any branch without switching to it.
#4,812 decision · per-seat limits#4,809 prompt · rate-limit the public API
It remembers.
Every prompt and decision is kept by Polis and searchable by your agents. Polis Memory System
Also: native runs on Claude Code or Codex, voice and on-device dictation, missions across browser tabs, and one chat that follows you across every surface.
The structure
A plan, made a document.
In a chat, a plan is a message you answer and scroll past. In Redline it has an identity, a state, a history, and an approval at the end.
Identity
Every paragraph has an anchor.
Each block carries a stable id that survives every edit, revision and export. Comments stick to the paragraph, not a position — rewrite the section in v7 and your note from v3 is still on it.
- Stable block ids
- Survive every revision
- Plain markdown underneath
State
Every comment has a lifecycle.
A comment moves from draft to submitted to resolved to accepted, or back to reopened. The agent owes a resolution for each one, and only you accept it.
- Edit · feedback · question
- A resolution per comment
- Nothing auto-accepted
History
Every revision is kept.
v1 through vN, each one restorable and exportable as Markdown or DOCX. The document isn’t the latest message about the plan. It is the plan, and how it got there.
- v1 … vN
- Restorable
- Markdown and DOCX
Approval
Done has a definition.
Nothing proceeds until you approve. Then the held agent builds from the approved plan — now, later, or with a team of agents.
- Approve & build
- Build later
- Build with a team
The protocol
How the agent is held.
Redline isn’t another coding agent. It sits in front of the one you already use, through that agent’s own hooks, and holds it while you review. Three modes set how firmly.
Claude Code
A PreToolUse hook on ExitPlanMode sends the plan to Redline’s local daemon and holds the session.
Codex
A Stop hook and a plan contract catch the proposed plan. Approval queues the build back in Codex.
Cursor
Prompt, response and stop hooks catch the plan; your revision returns as the agent’s next message.
Antigravity
Preview. A held Stop hook reads the latest plan from the conversation transcript.
Active
Every plan blocks and waits for your review.
Ambient
A decision window with a countdown: claim it to review, or let it approve itself.
Paused
A kill switch. Plans pass straight through and nothing is captured.
It waits as long as you do.
A held plan waits up to twelve hours for your review, with the agent’s session open the whole time.
Ask, or revise.
Send only questions and the plan comes back answered and unchanged. Send anything else and it comes back as a new revision.
Every comment is answered.
The next revision carries a resolution for each comment. Accept it, or reopen it with a note for the next round.
one review · Claude Codeillustrative
- hookExitPlanMode → POST 127.0.0.1:7676/v1/plan
- holdsession held · waiting for your review
- review1 edit · 1 feedback · 1 question
- sendrevise · 3 comments back to Claude
- v23 resolutions attached
- approveapprove & build · session released
The philosophy
What we believe about plans.
The plan is the unit of work.
Not a message, not a prompt, not a stage on the way to the real artifact. Builds, reviews and the memory of what you decided are all downstream of it.
“In agent-driven work, the plan document is the unit of work.”
Judgment belongs upstream.
By the time an agent has written four hundred lines, every decision that shaped them was made in the plan. That’s where a minute of your review is worth the most.
“The leverage moved upstream. The tooling stayed where it was.”
Get the document right.
When the plan is right, what follows is mostly execution. When it’s wrong, no amount of diff review saves it — the decision is already load-bearing.
“Get the document right and most of what follows is bookkeeping.”
Addressed is a state, not a feeling.
Every comment gets a resolution, and you decide whether it’s accepted. Nothing closes itself.
“Nothing is auto-accepted.”
The document model is the product.
A plan lives in one internal model, and every file format — Markdown, DOCX — is an adapter at its edge, not the thing itself.
“The internal document model is the product.”
Your work stays on your machine.
The daemon listens on localhost only. The network is reached only when you act: browsing, your agents’ model calls, optional cloud voices.
“There is no analytics, crash-reporting, or licensing phone-home.”
Quoted lines are from the Redline thesis and documentation.
By design
12ha plan can be held open for your review
4coding agents intercepted through their own hooks
1resolution owed for every comment you send
0analytics, crash reports or licensing checks
The cheapest place to catch a mistake is the diff the plan.
Built by a lawyer who wanted to mark up plans the way contracts get marked up: tracked changes, margin comments, and nothing accepted until it’s resolved.
Get started
An early release for macOS, built from source. Free and open source, local-first, with no account and no telemetry.
macOS 11+ · Node.js 22.12+ (or 20.19+) · Rust · Xcode Command Line Tools · CMake. Keep Claude Code installed for the full workspace.
Full setup guideBuild from source
git clone https://github.com/sersiousSenpai/redline.git
cd redline
npm ci
npm run redlineBuilds, installs, and opens Redline on your Mac.