For coding agents

1 · MCP server

Connect the Cobalt MCP server and your agent can pull any review — the reviewer's notes as text plus each annotated screenshot as a real image — and write new ones. Add it to your editor:

Cursor and VS Code install in one click. Claude Code and Codex copy a command to run in your terminal, then restart the app.

Or by command — Claude Code shown; every client uses the same endpoint, https://cobaltcapture.com/mcp, over Streamable HTTP:

--scope user is doing real work there: without it the server registers for one project only and silently does nothing everywhere else. With it, run it from any folder and it applies everywhere.

Ready-made tests

Connecting the server also gives your agent pre-built test playbooks, which appear as slash commands. In Claude Code:

Runs a first-time-user pass on that site — signs up, works through the main tasks, and hands back a review with the verdict at the top. The URL is the only thing you supply. It works whether or not you have the codebase open; if you do, findings come back with file and line references.

It proposes personas and jobs first and waits for your OK before touching the browser — that's the one place worth thirty seconds of your attention.

Audits the site's positioning and messaging — who is this for, what does it claim, does the page prove it — across the key public pages on desktop and phone. Read-only and fully autonomous: no accounts, no sign-ups, no approval stops; it runs start to finish and hands back the review link.

Walks a flow you name — signup, checkout, inviting a teammate — and reports what broke and what merely confused, step by step with a screenshot each. Describe the flow in a sentence; you don't write a script. It also audits any email the flow sends, rendered and judged like any other screen, which is the leg most reviews never reach.

Every run opens the same way: it tells you the steps it's about to take and exactly what it needs from you — usually nothing — before it touches the browser.

Read: get_review

Give it a review URL (/r/<slug> or /s/<slug>) or a bare slug, and it returns the review markdown followed by each composed screenshot (annotations burned in) as an image/png block. Then just ask your agent: "Read the Cobalt review <url> and make the changes it asks for."

Write: create_review, add_screenshot, add_note, update_review

Point an agent at a browser task and have it compile the findings into a review as it goes — screenshots stored durably, not lost between tool calls. No account required. create_review returns a review link and a token; the agent passes that token to add_screenshot / add_note to fill it in. Just tell your agent: "Use the cobalt MCP server. Create a review, walk through signup on example.com, and add each screen with a note on what's confusing. Give me the link."

When the run finishes, the agent calls update_review with the headline findings — so the verdict lands at the top of the review rather than buried under every intermediate screenshot. Agent-built reviews have a lot of intermediate steps, and both a human skimming and an agent re-ingesting the review want the conclusion first.

Reviews created this way are anonymous and auto-expire after 30 days; the returned link carries a one-click save-to-account option. Machine-readable manifest: /.well-known/mcp.json. Reads are public — no auth, the same access as opening the link in a browser.

2 · Getting screenshots in

add_screenshot needs a real image, and the way in is a URL. POST the image to /api/upload and pass back the url it returns — no auth, rate-limited per IP.

Do it inside the script that took the screenshot. If your agent drives a browser, it's already running a script with permission to run; uploading from that same script costs no extra shell call and no second permission prompt:

page.screenshot(path="shot.png")
url = requests.post("https://cobaltcapture.com/api/upload",
                    files={"file": ("shot.png", open("shot.png", "rb"), "image/png")}
                   ).json()["url"]
# → https://images.cobaltcapture.com/captures/….png

The 3-tuple is required. Without an explicit content type requests sends application/octet-stream and the upload is refused with "not an image".

That matters more than it looks: sandboxed agents gate shell commands, so a separate curl step is an extra approval your run can stall on. Same POST, one less prompt. (Playwright's own request context does the job in Node.)

There's a base64 image parameter too, but it's for small images only. Tool-call arguments are text the model generates, so passing a screenshot that way means emitting tens of thousands of base64 tokens perfectly — and a screenshot that reached the agent as an image can't be transcribed at all.

Some browser-automation tools only show the agent a screenshot without giving it a file it can upload. For those, use screen share. One click, nothing to install:

1. Open a Cobalt editor page (/new) in the same browser your agent is driving.
2. You click Capture once and pick the window to share. Browsers require a real gesture to start a screen share, so this step can't be automated — but the grant lasts the whole session.
3. Your agent calls window.cobaltGrab() on that page (via its JavaScript tool) for each screen. It returns { ok, url }.
4. The agent passes that url to add_screenshot as image_url.

Full-resolution capture, and it costs no tokens — the image goes straight to storage rather than through the model.

3 · Test accounts

Reviewing a product usually means signing up first. Ask Cobalt for an inbox and the agent can complete a real signup on its own.

1. create_inbox() → an address and an inbox_token.
2. The agent signs up with that address.
3. check_inbox(address, inbox_token) → the verification email, so it can pull the code or link and carry on.

No API key, no account, nothing to configure. If the Cobalt MCP server is connected, your agent already has this.

Inboxes are temporary — use a fresh one per test persona.

4 · Or just paste the link

No setup required. When an AI fetcher opens a review URL, Cobalt serves the markdown export instead of the HTML page — with the reviewer's annotations described in text and a note telling the agent to fetch and view each screenshot. Works in any agent that can browse the web.

You can also grab the same markdown yourself from any review's share section (Copy as markdown), or append /markdown to a review URL.

There's no separate REST API — a review's shareable URL, its markdown, and the MCP server above are the whole agent-facing surface.