Redline MCP
Lets ChatGPT and Codex CLI consume Redline requests, apply requested UI changes, and update per-mark status through the MCP server.
This server does not currently have a deployable release on Glama. Follow the repository's setup instructions to install and configure it for your MCP client, including any required credentials and local dependencies.
Redline ✎
Mark up your screen, and let your AI agent make the UI changes.
A real-time visual feedback tool for AI-driven frontend development. Triggered by a hotkey, it lets you draw and annotate UI/UX changes directly on your screen—from layout fixes to styling tweaks. The Electron menu-bar app and built-in MCP server feed annotated screenshots straight to Claude or any AI agent to apply code changes instantly.
Redline is a small desktop app plus an MCP server. Press a hotkey, draw boxes, arrows and pins on whatever is on screen, and write what should change. Then tell Claude, ChatGPT, Antigravity or any MCP-capable agent "apply my latest Redline". The agent gets the annotated screenshot, a zoomed crop of every mark and exact coordinates. It finds the matching code, makes the changes and reports back per mark, and you confirm each one in the app.
⌥⇧M / Alt+Shift+M ──► freeze-frame of the screen under your cursor
draw: Box (R) · Arrow (A) · Pen (P) · Pin (I), add a comment to each mark
⌘↵ / Ctrl+Enter save Esc cancel ⌘Z / Ctrl+Z undo N = overall note H = history
──► ~/.redline/requests/<id>/
──► Redline MCP → agent reads the request, edits code, sets each mark to "review"
──► you click ✓ Looks good (or ↺ Not done)Download
v0.0.1-beta (pre-release) · all releases
Platform | Installer |
macOS · Apple silicon | |
macOS · Intel | |
Windows 10 / 11 · x64 | |
Linux · x64 (any distro) | |
Linux · Debian / Ubuntu |
The builds are not code-signed yet, so the first launch shows a security prompt (macOS: System Settings → Privacy & Security → Open Anyway; Windows: More info → Run anyway). The app includes the MCP server: open Connect an agent from the menu-bar / tray icon to set up Claude, Codex, Cursor and others.
Related MCP server: redpen
Contents
Run the desktop app (macOS · Windows · Linux)
Connect the MCP server (Claude Code · Claude Desktop · ChatGPT · Codex CLI · Antigravity)
Using it (step-by-step walkthrough with screenshots)
Why
Describing visual tweaks in words ("the button under the subtitle, make it a bit smaller") is slow and easy to get wrong. With Redline you point at the thing. The agent gets the picture, the location and the context (app, window title, browser URL), so it knows exactly what you mean.
Features
Global hotkey capture. Freezes the display under your cursor, so you can annotate anything: a browser tab, a native app, a design file.
Four mark types: box, arrow, freehand pen and pin. Each one is numbered, color-coded and has its own comment.
Output that vision models can read: an annotated image with comments drawn in, a downscaled preview, a zoomed crop per mark, and a structured description with pixel and normalized coordinates.
Per-mark status tracking:
open → in_progress → review → done, pluspartialandwontfix. Agents leave notes that you see in the app.History view. Reopen any request, move or resize marks, edit comments, confirm or reject the agent's work, or delete requests.
Context capture (macOS). It records the frontmost app, window title and browser URL.
Local and private. Requests are plain files on your disk. The app and the MCP server share one folder, and nothing is uploaded unless you expose the server yourself.
Platform support
macOS | Windows | Linux | |
Capture, markup, history | ✅ tested | ✅ should work | ✅ X11 · ⚠️ Wayland (see below) |
Global hotkeys | ✅ | ✅ | ✅ X11 · ⚠️ Wayland |
App / window / URL context | ✅ | — | — |
MCP server | ✅ | ✅ | ✅ |
Redline is built on Electron and developed on macOS. Windows and Linux use the same code path for
screen capture and hotkeys, but they have had less testing, so please open an issue if something breaks.
On Linux Wayland, screen capture goes through the desktop portal (you may see a "share screen" prompt),
and global hotkeys may not register. If they don't, bind npm run app -- --capture to a shortcut in your
desktop environment's keyboard settings, or log in with an X11 session.
Install
You need Node.js 18 or newer (developed on Node 24) and git.
git clone https://github.com/sislamrafi/redline.git
cd redline/desktop-app
npm installAll commands below run from desktop-app/.
npm install also downloads Electron for your OS.
Run the desktop app
Redline runs in the background with a ✎ icon in the menu bar (macOS) or system tray (Windows and Linux). It keeps running until you choose Quit from that icon, so capture is always one hotkey away.
Action | macOS | Windows / Linux |
Mark up the screen |
|
|
Open history |
|
|
The same commands work on every OS:
npm run app # start Redline in the background (tray icon + hotkeys)
npm run app -- --capture # trigger a capture (from a launcher, script or custom shortcut)
npm run app -- --history # open the history
npm run app -- --selftest # render a demo request without touching the screen, then quitIf Redline is already running, --capture and --history are passed to the running copy,
so you can bind them to Raycast, Alfred, AutoHotkey or your desktop's custom shortcuts.
macOS
cd ~/path/to/redline/desktop-app
npm run appThe first capture needs Screen Recording permission: open System Settings → Privacy & Security → Screen Recording and allow Electron, or the terminal you started Redline from. Then quit and restart Redline.
Reading the window title and browser URL may ask for Accessibility or Automation access. This is optional; capture works without it.
Run it as a standalone Redline.app (recommended)
With npm run app, macOS ties the Screen Recording permission to whatever launched it (Terminal, VS Code, Claude…).
To give Redline its own entry in Privacy settings, build a real app bundle:
npm run mac:install # builds dist/mac-arm64/Redline.app, copies it to /Applications and opens itThen allow Redline under System Settings → Privacy & Security → Screen Recording and restart it.
The bundle is only a thin launcher (build/mac-loader.cjs): it loads app/main.js from this checkout,
so code edits take effect the next time you quit and reopen Redline, with no rebuild needed and the permission kept.
Rebuild only after moving the repo or upgrading Electron. You can point it at another checkout with REDLINE_SRC=/path/to/redline/desktop-app.
Windows
In PowerShell or Command Prompt:
cd C:\path\to\redline\desktop-app
npm run appNo extra permission is needed for screen capture.
If
Alt+Shift+Mclashes with another app (some keyboard layouts useAlt+Shiftto switch language), choose another hotkey:$env:REDLINE_HOTKEY="Control+Shift+M"; npm run appThe tray icon may be hidden under the ^ overflow arrow in the taskbar.
Linux
cd ~/path/to/redline/desktop-app
npm run appOn Ubuntu 24.04 and other distros that restrict unprivileged user namespaces, Electron may stop with a sandbox error. Run it with
npm run app -- --no-sandbox, or fix the permissions onnode_modules/electron/dist/chrome-sandboxas the error message describes.GNOME doesn't show tray icons by default. Install the AppIndicator and KStatusNotifierItem Support extension to see the ✎ icon. The hotkeys work without it.
On Wayland, see Platform support.
Start automatically at login
To have Redline always ready, start it when you log in. In each example, replace /path/to/redline/desktop-app with
the desktop-app folder inside the repo you cloned.
macOS: Launch Agent
Create ~/Library/LaunchAgents/com.redline.app.plist:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>Label</key><string>com.redline.app</string>
<key>ProgramArguments</key>
<array>
<string>/path/to/redline/desktop-app/node_modules/.bin/electron</string>
<string>/path/to/redline/desktop-app</string>
</array>
<key>RunAtLoad</key><true/>
<key>KeepAlive</key><false/>
</dict>
</plist>launchctl load ~/Library/LaunchAgents/com.redline.app.plistTo stop it starting at login: launchctl unload ~/Library/LaunchAgents/com.redline.app.plist.
Windows: Startup folder
Press
Win+R, typeshell:startupand press Enter.In that folder, create
redline.vbswith the following content. It starts Redline without leaving a console window open.Set sh = CreateObject("WScript.Shell") sh.CurrentDirectory = "C:\path\to\redline\desktop-app" sh.Run "cmd /c npm run app", 0, False
To stop it starting at login, delete redline.vbs.
Linux: XDG autostart
Create ~/.config/autostart/redline.desktop:
[Desktop Entry]
Type=Application
Name=Redline
Comment=Mark up your screen for AI agents
Exec=/path/to/redline/desktop-app/node_modules/.bin/electron /path/to/redline/desktop-app
X-GNOME-Autostart-enabled=trueAdd --no-sandbox to the end of the Exec line if you needed it above. To stop it starting at login, delete the file.
Connect the MCP server
Easiest: the first time Redline starts, it opens a setup guide (later: tray menu → Connect an agent…, or Connect agent in History). Pick your agent (Claude Code, Cursor, Codex, Windsurf, Antigravity, Claude Desktop, VS Code, ChatGPT…), copy the command-line command or the prompt into your agent, and the guide shows ✓ as soon as the agent connects. The steps below do the same by hand.
The MCP server is desktop-app/mcp/server.js. It talks over stdio and reads the same ~/.redline folder as the app.
Every client below needs the absolute path to that file:
OS | Example path |
macOS |
|
Linux |
|
Windows |
|
The desktop app doesn't need to be running for the MCP server to work. It only has to be running when you want to capture new markups.
Claude Code
Available in every project (recommended):
claude mcp add --scope user redline -- node /absolute/path/to/redline/desktop-app/mcp/server.jsCheck that it connected:
claude mcp listTo add it to one project only, run the command inside that project with --scope project instead.
This writes a .mcp.json file that you can commit. In the Claude desktop app's Code tab, the servers you
add with claude mcp add are picked up automatically.
The /redline command (recommended)
Install a short slash command so you don't have to remember the MCP prompt names:
cd desktop-app && npm run claude:command # copies claude/commands/redline.md to ~/.claude/commands/Then in Claude Code:
Type | What it does |
| Apply your latest markup and report back per mark |
| Apply every open request |
| Show all requests and their status |
| Summarize what's waiting for your confirmation |
| Apply one specific request |
| Apply the latest with extra instructions |
The server also tells the agent what Redline is, so plain phrases like "apply my latest redline" or "fix my markup" work too.
The MCP prompts are available as /mcp__redline__apply, /mcp__redline__list and /mcp__redline__check.
Claude Desktop (chat)
Open Settings → Developer → Edit Config, or edit the file directly:
OS | Config file |
macOS |
|
Windows |
|
{
"mcpServers": {
"redline": {
"command": "node",
"args": ["/absolute/path/to/redline/desktop-app/mcp/server.js"]
}
}
}Fully quit and reopen Claude Desktop. The Redline tools then appear in the tools menu of the chat box. Claude Desktop isn't available for Linux; use Claude Code there.
ChatGPT
ChatGPT connects only to remote MCP servers over HTTPS. It can't start a local stdio server the way Claude does, so you run a small bridge that serves Redline over HTTP and expose it with a tunnel.
⚠️ Privacy: a tunnel URL makes your screenshots readable by anyone who has the URL, and this bridge has no authentication. Only run it while you use it, keep the URL private, and stop the tunnel afterwards.
Serve Redline over HTTP with supergateway:
npx -y supergateway --stdio "node /absolute/path/to/redline/desktop-app/mcp/server.js" \ --outputTransport streamableHttp --port 8787On Windows PowerShell, put it on one line and leave out the
\.Give it a public HTTPS URL in a second terminal, with cloudflared (free, no account needed for quick tunnels) or ngrok:
cloudflared tunnel --url http://localhost:8787It prints a URL like
https://random-words.trycloudflare.com.Add it in ChatGPT: go to Settings → Apps & Connectors → Advanced, turn on Developer mode, then create a connector:
MCP Server URL:
https://random-words.trycloudflare.com/mcpAuthentication: none
Developer mode needs a paid plan, and on Business, Enterprise and Edu an admin may have to allow it. Menu names change from time to time; see OpenAI's help center if yours look different.
In a new chat, turn on the Redline connector and ask: "Use Redline to show my latest edit request."
ChatGPT can read your markups this way, but it can't edit the code on your computer. To have changes applied to your code, use an agent that runs locally, such as Claude Code, Codex CLI or Antigravity.
OpenAI Codex CLI
Codex CLI runs locally and supports stdio servers directly. Add this to ~/.codex/config.toml
(%USERPROFILE%\.codex\config.toml on Windows):
[mcp_servers.redline]
command = "node"
args = ["/absolute/path/to/redline/desktop-app/mcp/server.js"]Or from the terminal:
codex mcp add redline -- node /absolute/path/to/redline/desktop-app/mcp/server.jsGoogle Antigravity
In the Agent panel, open the ⋮ menu → MCP Servers → Manage MCP Servers → View raw config. This opens
mcp_config.json. Depending on your version, it's at~/.gemini/config/mcp_config.jsonor~/.gemini/antigravity/mcp_config.json. On Windows,~is%USERPROFILE%.Add Redline under
mcpServers:{ "mcpServers": { "redline": { "command": "node", "args": ["/absolute/path/to/redline/desktop-app/mcp/server.js"] } } }Save the file and click Refresh in Manage MCP Servers. Redline's four tools should be listed.
To add Redline to one workspace only, put the same JSON in .agents/mcp_config.json in that project.
Other MCP clients
Cursor, Windsurf, VS Code (Copilot), Cline, Zed and others use the same command / args entry.
Look for "MCP servers" in their settings and point it at node /absolute/path/to/redline/desktop-app/mcp/server.js.
Using it
This walkthrough follows one real request: making a heading on a web page a little bigger.
Step 1: Add the Redline MCP to Claude (one-time setup)
Your agent can only see your markups after the Redline MCP is added. Do this once, before your first request:
claude mcp add --scope user redline -- node /absolute/path/to/redline/desktop-app/mcp/server.jsclaude mcp list # should show: redline … ✓ ConnectedFor Claude Desktop, ChatGPT, Codex CLI or Antigravity, see Connect the MCP server.
Also make sure the desktop app is running (npm run app); look for the ✎ icon in the menu bar or tray.
Step 2: Mark up the screen
Open the page or app you want to change and press ⌥⇧M (macOS) or Alt+Shift+M (Windows/Linux). The screen freezes and the Redline toolbar appears at the top.
Choose a tool: Box (R), Arrow (A), Pen (P) or Pin (I).
Click or drag on the thing you want changed. A numbered mark appears.
Type what should change in the comment box, for example "make this text a little bigger". Set the status there too, or delete the mark.
Add more marks if you need them. To give the whole request a note, type it in the Overall request field in the toolbar, or press N.
Click Save, or press ⌘↵ / Ctrl+Enter. Press Esc to cancel.

Step 3: Check it in the history
Press ⌥⇧H / Alt+Shift+H, or click History in the toolbar, to see every request. The tabs sort them by where they stand:
Tab | Meaning |
To do | New requests, and requests the agent is still working on |
Confirm | The agent says it's finished; waiting for you to check |
Done | You confirmed the result |
All | Everything |
Each card shows the screenshot, your first comment, the app it came from, and how many marks are finished. Click a card to reopen the request and edit it.

Step 4: Ask Claude to apply it
Open Claude in the project that contains that UI (here, the website's code) and ask in plain words:
read the Redline comments and fix the things mentioned there
In Claude Code just type /redline (see the /redline command), or say "apply my latest Redline".

Claude then:
calls
get_edit_requestand receives the annotated screenshot, a zoomed crop of each mark and its coordinates;finds the matching code from the visible text, the page URL and the layout, and makes the change;
calls
update_edit_request_statusto move each mark to Waiting for confirmation, with a note naming the file it changed.
Step 5: Confirm the result
Reload the page and check the change. In the History, the request is now under Confirm. Open it, click a mark, and choose ✓ Looks good (or Confirm all). If it isn't right, choose ↺ Not done and add a comment saying what's still wrong. The mark goes back to To do, and the next time you ask, Claude picks it up again.
MCP reference
Tool | What it does |
| Lists requests, newest first. Filter by |
| Returns the annotated preview, a crop per unfinished mark and a structured description. |
| Sets the status of individual marks and/or the whole request, with notes the user sees. |
| Permanently deletes a request and its images. Use it only when the user asks. |
Prompt | What it does |
| Fetches the latest request, implements each unfinished mark in the current codebase and reports per mark ( |
| Lists every request with its status. |
| Summarizes what's waiting for your confirmation. |
Agents set finished marks to review, not done. You confirm them in the app.
If you edit or move a mark, it goes back to open, so the next agent picks it up again.
Storage layout
~/.redline/requests/<id>/
request.json marks (pixel + normalized coords), comments, status, app/window/URL context
screenshot.png untouched original
annotated.png numbered, color-coded marks with comment callouts (full resolution)
preview.png the same image, ≤1600px wide (what the MCP server sends)
crops/mark-N.png zoomed crop around each mark
prompt.md a description that ties each #N and its color to a locationOn Windows, ~ is your user folder (C:\Users\you\.redline).
Configuration
Variable | Default | Purpose |
|
| Capture hotkey (Electron accelerator syntax, e.g. |
|
| History hotkey |
|
| Storage folder, used by both the app and the MCP server |
If you change REDLINE_HOME, set it for the MCP server too: add "env": { "REDLINE_HOME": "..." }
to the server entry in your MCP config.
An existing ~/.annotation-mcp folder from older versions is moved to ~/.redline automatically.
Project structure
desktop-app/ the installable Redline app + MCP server (run npm commands here)
app/
main.js Electron tray app: hotkeys, screen capture, windows, IPC
preload.cjs bridge between the renderer and main process
renderer/ markup editor and history UI (HTML/CSS/JS)
mcp/server.js MCP server (stdio)
shared/store.js on-disk store and status logic, shared by the app and the server
scripts/
mcp-smoke.js end-to-end smoke test against the MCP server
mcp-call.js call one MCP tool from the CLI: node scripts/mcp-call.js <tool> '<json>' [outDir]
build/ icons, electron-builder hooks, local macOS launcher
portfolio-website/ the redlinez.org landing page (static HTML/CSS/JS, no build step)
docs/images/ screenshots used in this READMEDevelopment
npm run mcp # run the MCP server on stdio
node scripts/mcp-smoke.js # list tools, fetch the latest request and update its statusThe smoke test changes the status of your latest request to done. Point REDLINE_HOME at a scratch
folder if you don't want that.
Issues and pull requests are welcome.
Building installers and releases
Release builds bundle the app code (unlike the local npm run mac:install launcher) and are configured in the
build section of package.json:
npm run dist:mac # dist/Redline-<version>-mac-arm64.dmg and -mac-x64.dmg
npm run dist:win # dist/Redline-<version>-win-x64.exe (NSIS installer); build on Windows
npm run dist:linux # dist/Redline-<version>-linux-x86_64.AppImage and -linux-amd64.deb; build on LinuxTo publish a GitHub Release, bump the version and push the tag. The Release workflow
builds on macOS, Windows and Linux and attaches every installer to one draft release. Review it on GitHub, then click Publish release.
Tags with a suffix such as v0.0.1-beta are marked as pre-releases.
cd desktop-app && npm version 0.2.0 --no-git-tag-version && cd ..
git commit -am "Release v0.2.0" && git tag v0.2.0 && git push && git push origin v0.2.0The builds are not signed with an Apple Developer ID or a Windows code-signing certificate, so first launch shows a warning:
macOS: "Redline can't be opened / is damaged". Open it once from System Settings → Privacy & Security → Open Anyway, or run
xattr -dr com.apple.quarantine /Applications/Redline.app.Windows: SmartScreen "Windows protected your PC". Click More info → Run anyway.
The installers contain the desktop capture app only. The MCP server is still run from a checkout (see Connect the MCP server).
License
Redline is released under the MIT License. © 2026 S Islam Rafi.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
This server cannot be deployed
Maintenance
Related MCP Connectors
Annotated-screenshot reviews and ready-made product studies your AI agent can read, run, and share.
A design agent in your coding agent's loop: briefs each screen, reviews UX and visual quality.
Turn screen recordings and video links into change lists with screenshots an AI can act on.
Captured web interfaces, screenshots, flows and structured evidence for AI coding agents.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables AI coding agents to capture screen and voice recordings, extract timestamped frames, and receive structured Markdown reports with context for bug fixing and UI feedback.9 npm19MIT
- AlicenseNot gradedqualityBmaintenanceEnables coding agents to capture pixel-accurate screenshots and DOM state from localhost apps, receive user-drawn instructions and reference images, and manage implementation review cycles.7 npmMIT
- AlicenseNot gradedqualityBmaintenanceEnables coding agents to pull structured UI feedback captured in the browser — including element selectors, bounding boxes, computed styles, screenshots, and annotations — and to mark issues as fixed.MIT
- AlicenseNot gradedqualityCmaintenanceEnables AI coding agents to read point-and-talk review notes with marked screenshots, fix them by number, and report each fix back with proof so nothing is considered done until verified.MIT