Skip to main content
Glama

Most IDEs are built for writing code. Reado is built for reading it.

Your agent writes more code than you do now. The job that's left is reading it and deciding — and that deserves a tool of its own. In Reado you read, and you leave comments anchored to the exact lines that matter; your agent (Claude Code, Codex, Copilot, Gemini, OpenCode or Cursor) resolves them, and you review what changed.

Inverted code review: you are the reviewer, the AI is the committer.

Related MCP server: fix-my-comments-mcp

A guided review, with an AI pair

Pick what to review — your working changes, a branch, a pull request — and a focus: bug risk, security, performance, test coverage. The agent plans a route through the change, reviews it file by file and proposes; nothing is final until you approve it.

Comments that stay where you left them

A Reado comment is not a sticky note. It is anchored to a line range, typed (bug, refactor, performance, question, note), threaded, and either a task for the agent or a note for the next reader. Comments live next to your code as plain Markdown in .reado/, and they survive edits: when the code moves, they re-anchor with it — and one whose code is gone becomes an orphan instead of quietly pointing at the wrong line.

Your agent does the work — you watch it happen

Send review hands your open tasks to the agent running in Reado's terminal. It works through the reado CLI and MCP server — reading your comments, consulting the project's docs and specs, resolving each task — and Reado reflects every step live: the reasoning, the files it touches, the task closing. When it's done, a Δ on the file tree takes you straight to what changed since you last read it.

An IDE that reads like a book

  • Built for reading: a calm CodeMirror 6 viewer with comfortable line length, sticky scope headers, an outline, go-to-definition and code intelligence.

  • Reading coverage: Reado knows what you have actually read, and what changed underneath you since.

  • Project tours: ship a tour.json with your repository and anyone who opens it in Reado can walk the code you'd explain to a newcomer, the exact lines lit up and explained step by step. The format is open — any tool can read and write it.

  • A knowledge base that grows as you read: the project's docs, specs (OpenSpec, Spec Kit) and your notes in one searchable place, plus a graph linking comments, files, specs and docs.

  • A browser your agent can drive: preview your app inside Reado, comment on the page itself, and let the agent inspect the DOM, console and network.

  • Reado Anywhere: pair your phone to follow a review, comment from it, and get pinged when the agent is done.

  • Four research-grounded themes — dark, light, high contrast, sepia — and a UI in English, Italian, Spanish, French and German.

Local-first, open source

Reado is MIT and runs on macOS, Linux and Windows. Your code and your comments stay on your machine as plain files; an account is optional and never gates the app.

Download

Grab the latest signed build from Releases — macOS (.dmg, signed & notarized), Linux (.AppImage / .deb / .rpm) and Windows (.exe / .msi). Reado updates itself from signed releases after that.

The AI loop

Reado's core loop is read → annotate → AI-resolve:

  1. You read code and leave comments. Comments flagged as tasks are the work list; notes stay out of the agent's way.

  2. Open the terminal (Cmd/Ctrl+J), launch Claude, Codex or Copilot, then click Send review. Reado injects a prompt pointing the agent at your open tasks.

  3. The agent reads your tasks and comments — from the reado://tasks and reado://comments MCP resources, or reado task list — makes the changes, and marks each done with reado task done <id> (or reado task fail <id> "<reason>"). Reado's watcher reflects the result live, and resolved comments move to history.

The reado binary is the stable contract — the on-disk format can evolve without breaking the agents. It serves both the MCP server (reado mcp, auto-wired into each agent's config on project open) and the CLI the agent calls, so it must be on the agent's PATH for the AI loop to work. The packaged app bundles it: install from Settings → Command-line tool (links reado into ~/.local/bin, VS Code style). The MCP server is also listed in the official MCP Registry as io.github.WatermelonBros/reado, as a bundle with the binary for macOS, Linux and Windows. From a source checkout, build and link it directly:

scripts/install-cli.sh           # builds release + links into ~/.local/bin
reado --help

Actions (CLI): reado task list|show|done|fail|link, reado comment add|reply|search, and reado kb list|show|search (to consult the docs and specs before resolving). Context (MCP): the reado://tasks, reado://comments, reado://reading-progress and reado://bookmarks resources, plus browser_* tools for the in-app preview. Agent identity comes from $READO_AGENT (Reado sets it when launching an agent).

An agent plugin in plugin/ teaches Claude Code (and Codex, via AGENTS.md) this contract so the agent resolves tasks correctly. See plugin/README.md to install it. Other agents (e.g. Copilot) still get the contract from the Send review prompt Reado injects, as long as the reado CLI is installed.

Keyboard shortcuts

Shortcut

Action

Cmd/Ctrl + P

Go to file (fuzzy)

Cmd/Ctrl + K

Command palette

Cmd/Ctrl + Shift+F

Search & replace in project

Cmd/Ctrl + ,

Settings

Contributing

Reado aims to be a friendly open-source project, and contributions are welcome. Everything you need to build, test and send a change — prerequisites, the dev loop, the checks CI runs, conventions — is in CONTRIBUTING.md. Please read our Code of Conduct; security issues go through SECURITY.md.

License

MIT © Reado contributors

Available Tools

27 tools
browser_animationA
Read-onlyIdempotent

Read the animations running on one element of the preview, as JSON: for each, its name, keyframes and computed timing (duration, delay, easing, progress). Answers an empty list when it has none, null when nothing matches. Needs Reado's browser preview open with agent access on: without it the call fails after about 6 s with "no preview pane running". On a page holding a credential it is refused until the user grants access.

Inputs: selector (required).

browser_clickA

Click an element in the preview: scrolls it to the middle of the viewport, then fires a DOM click(). Answers clicked, or not found when nothing matches. It does not wait for what the click sets off — check the outcome with browser_dom, browser_errors or browser_frame. Needs Reado's browser preview open with agent access on: without it the call fails after about 6 s with "no preview pane running". On a page holding a credential it is refused until the user grants access.

Inputs: selector (required).

browser_consoleA
Read-onlyIdempotent

Read everything the preview page logged, as JSON: each entry's level (log/info/warn/error), message, source and stack. Use it to follow what the app is doing; for only what broke, browser_errors is shorter. Reads what Reado captured without touching the page; when no preview is open it answers that none is running.

Inputs: no named parameters.

browser_domA
Read-onlyIdempotent

Inspect one element of the preview: its tag, outerHTML (first 2000 characters), box (x, y, width, height in CSS px, relative to the viewport) and key computed styles (display, color, background, font), as JSON; null when nothing matches. Use it to check structure and layout; for a picture use browser_frame, for anything else browser_eval. Needs Reado's browser preview open with agent access on: without it the call fails after about 6 s with "no preview pane running". On a page holding a credential it is refused until the user grants access.

Inputs: selector (required).

browser_errorsA
Read-onlyIdempotent

Read only the preview's error-level console entries — errors and unhandled rejections — as JSON: the part of browser_console that answers "what broke?". Answers No errors captured. when there are none. Reads what Reado captured without touching the page; when no preview is open it answers that none is running.

Inputs: no named parameters.

browser_evalA
Destructive

Run a JavaScript expression in the preview page and answer its value, JSON-serialized. The escape hatch for what the other browser_* tools don't cover — reading app state, calling page functions, scrolling a nested container; prefer them when they fit. Evaluated synchronously (a Promise is not awaited), and it can change the page. Needs Reado's browser preview open with agent access on: without it the call fails after about 6 s with "no preview pane running". On a page holding a credential it is refused until the user grants access.

Inputs: js (required).

browser_frameA
Read-onlyIdempotent

Screenshot the preview as it renders right now, answered as a PNG image. Use it to see layout and visual bugs, or the result of a click; for exact sizes and styles use browser_dom. Not available on Linux. Needs Reado's browser preview open with agent access on: without it the call fails after about 6 s with "no preview pane running". On a page holding a credential it is refused until the user grants access.

Inputs: no named parameters.

browser_hoverA
Idempotent

Hover an element in the preview by dispatching mouseover and mouseenter — to open a menu or tooltip before inspecting it. Answers hovered or not found. These are synthetic events, so CSS :hover styles do not apply. Needs Reado's browser preview open with agent access on: without it the call fails after about 6 s with "no preview pane running". On a page holding a credential it is refused until the user grants access.

Inputs: selector (required).

browser_navigateA
Idempotent

Load a URL in the preview, replacing the current page. Only localhost and the origins the user allowlisted can be opened; anything else is refused with "origin not allowed". Answers the URL loaded. Needs Reado's browser preview open with agent access on: without it the call fails after about 6 s with "no preview pane running". On a page holding a credential it is refused until the user grants access.

Inputs: url (required).

browser_networkA
Read-onlyIdempotent

Read the preview page's network activity, as JSON: method, URL, status and timing per request, with failures flagged. Use it to check API calls, failed fetches and slow responses. Reads what Reado captured without touching the page; when no preview is open it answers that none is running.

Inputs: no named parameters.

browser_scrollA
Idempotent

Scroll the preview's window to an absolute position (window.scrollTo) — to bring content into view before browser_frame. Answers scrolled. browser_click already scrolls its target; a nested scroll container needs browser_eval. Needs Reado's browser preview open with agent access on: without it the call fails after about 6 s with "no preview pane running". On a page holding a credential it is refused until the user grants access.

Inputs: x, y.

browser_typeA
Idempotent

Fill a form field in the preview: focuses it, replaces its whole value with text, then fires input and change. Answers typed or not found. No key events are sent, so keydown handlers and Enter-to-submit don't fire — click the submit button instead. Needs Reado's browser preview open with agent access on: without it the call fails after about 6 s with "no preview pane running". On a page holding a credential it is refused until the user grants access.

Inputs: text (required), selector (required).

comment_addA

Anchor a new comment to a line range, signed by the agent. A task (the default) joins the user's task queue as work to do; a note explains something to the next reader without asking for action. Answers the new comment's id and state as JSON. To answer an existing comment use comment_reply; during a guided review use review_propose_comment, which the human approves first.

Inputs: body (required), file (required), line (required), end, +2 more.

comment_replyA

Reply in an existing comment's thread, signed by the agent — to answer a question the user asked, or to explain what you changed. It does not change the comment's state: use task_done, task_fail or task_block for that. Answers the comment's id and state as JSON.

Inputs: id (required), body (required).

mascot_sayA

Say one line through Reado's mascot — the small companion in the corner of the user's screen. For the moment the user must know about while they are away from the desk: what you need from them, or what just landed. Not narration, not progress, not a running commentary: it interrupts a human, and a companion that chatters gets turned off. Use ask only when you are actually waiting for them. Text over 280 characters is refused, not truncated. Answers said: <text>.

Inputs: text (required), mood.

review_contextA
Read-onlyIdempotent

Read one file's context in a guided review before reviewing it, as JSON: the session objective, the file's route entry (why it was ranked, related files), its state, its running summary and the proposals already on it. For the whole session use session_show.

Inputs: file (required), sessionId.

review_planA

Set a guided review's ranked route — the planning pass, once per session, before you review any file. Answers how many files you routed and the uncovered ones: files the scope contains that your route left out. Route each with review_propose_route_change, or declare it out of scope with reado session set-file <id> --file <path> --state out-of-scope. Refused if the session already has a route; propose a change instead.

Inputs: route (required), sessionId.

review_proposeA

Propose a guided-review item that is not a finding on the code: a question for the human, a follow-up to do after the review, or needs-context when you cannot judge the code without information you don't have — prefer it to guessing. The human accepts or discards it. Answers the proposal's id. For a finding on specific lines use review_propose_comment.

Inputs: body (required), kind (required), file, line, +1 more.

review_propose_commentA

Propose a finding on the code during a guided review — a bug, a refactor, a performance issue — anchored to a line range. Only a proposal: the human accepts, edits or discards it, and only an accepted one becomes a comment. Answers the proposal's id. For a question or missing context rather than a finding use review_propose; outside a guided review, comment_add.

Inputs: body (required), file (required), line (required), end, +2 more.

review_propose_route_changeA
Idempotent

Propose a new route for a guided review already under way — a file you found that must be reviewed, a reorder, a file to drop. Nothing changes until the human accepts it in Reado: the current route keeps running, so carry on with the file you were on. A new proposal replaces one still pending. Answers a confirmation; refused without a reason.

Inputs: route (required), reason (required), sessionId.

review_summarize_fileA
Idempotent

Record a file's mini-summary when you finish reviewing it in a guided review: what you checked, the risks you see, what comes next. It replaces the file's earlier summary, and marks a file with no state yet as reviewed. Answers a confirmation. For the whole review use session_summarize.

Inputs: file (required), text (required), sessionId.

session_doneA

Call this when your next act is to wait for the user — the request is finished, you are blocked, or you need an answer. NOT after a command returns or a step completes: if you will do anything else before stopping, it is too early. Reado alerts a user who has walked away, so a premature call fetches them back for nothing. Answers an acknowledgement.

Inputs: status, summary.

session_showA
Read-onlyIdempotent

Read a guided-review session in full, as JSON: scope, objective, route, per-file state and summaries, proposals and their decisions, the files the scope is expected to contain, and any pending route change. Call it first on a READO GUIDED REVIEW prompt, or to find your place after losing context; for a single file, review_context is smaller.

Inputs: sessionId.

session_summarizeA
Idempotent

Record a guided review's overall recap once the routed files are done: what the review found, the risks that matter most, what is left. It replaces any earlier recap. Answers a confirmation. For one file's notes use review_summarize_file.

Inputs: text (required), sessionId.

task_blockA
Idempotent

Block a task you cannot finish without the human — a decision, a credential or context you don't have. It stays blocked with your reason until they answer in Reado, which reopens it with a fresh attempt count. Blocking again replaces the reason. Answers the task's id, state and reason as JSON.

Inputs: id (required), reason (required).

task_doneA

Mark a task resolved once your change addresses it, recording how. With verify, Reado runs that command in the project root: exit 0 marks the task done and archives it; a failure — or no verify at all — leaves it resolved-but-unverified, visible for the human to check. Answers the task's id, state and resolution as JSON. If the attempt didn't work use task_fail; if you need the human, task_block.

Inputs: id (required), model, verify, diffRef.

task_failA

Record a failed attempt at a task. The task goes back to open for another try; the third failed attempt blocks it until the human answers. Answers the task's id, state and attempt count as JSON. When you already know you need the human, use task_block instead.

Inputs: id (required), note.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.1/5.0

    Scored across 27 tools

    Disambiguation4/5

    Most tools target a distinct resource+action, and the descriptions explicitly disambiguate the tricky pairs (browser_errors as a subset of browser_console, review_propose_comment vs review_propose, comment_add vs comment_reply vs review_propose_comment). The only real overlaps are browser_console/browser_errors and the read-only session_show vs review_context, both of which the descriptions diff explicitly. No tool pair appears interchangeable.

    Naming Consistency4/5

    Consistent snake_case verb_noun throughout, with clear domain prefixes (browser_*, task_*, comment_*, review_*, session_*). Minor deviations exist: comment_add/comment_reply use different verbs than the task_* lifecycle, and the summarize action is split across review_summarize_file and session_summarize rather than following one prefix scheme. Still highly predictable overall.

    Tool Count3/5

    27 tools is on the heavy side and just past the threshold where a set starts to feel bloated. However, the surface spans three genuinely distinct sub-domains (browser automation/inspection, guided-code-review lifecycle, task/comment/notification handling), so most tools earn their place rather than being redundant variants.

    Completeness4/5

    Browser control, task state transitions, comment creation, review routing, proposal and summarization are all covered with no obvious dead ends for the stated review-oriented purpose. The main gap is read/enumeration: there is no way to list or fetch tasks or existing comments (only add/reply/transition), so an agent depends on work arriving via the prompt.

    Maintenance

    ActivityMaintained
    ResponsivenessLimited data

    Related MCP Connectors

    Related MCP Servers