Developers

Start a discussion. Body { "title"?: string }. Returns { "id", "title" }. A free plan past its month answers 402.

Your discussions, newest first: { "chats": [{ id, title, updated_at, status, … }] }.

One discussion and its messages: { "chat", "messages": [{ id, speaker, content, is_final, kind, meta }] }. Someone else's is 404, not 403.

Say something and let the room work. Body { "content": string, "images"?: [{ "name", "data": "data:image/png;base64,…" }] }. The response is a stream, one JSON object per line (application/x-ndjson):

{"type":"message_start","id":"…","speaker":"claude"}
{"type":"delta","id":"…","text":"…"}          the words, as they arrive
{"type":"message_end","id":"…"}
{"type":"consensus", …}                        the seats agreed, or did not
{"type":"speaker_error","speaker":"…","message":"…"}
{"type":"stopped"}                             you asked it to stop
{"type":"done", …}                             the run is over
{"type":"error","message":"…"}

Twenty turns a minute per account. A run past the plan's budget ends with an error event that says so.

Stop a running discussion. The stream ends with stopped.

After a discussion stops because the credit ran out: moves the seats it was spending credit on to Free Key and returns { ok, seats }. Send the next message to carry on. Refused, with the reason, when Free Key isn't available on the account or no seat spends credit. The discussion's author only.

{ "path": "artifacts/report.html", "html" } — keep a report a run on your Mac wrote, so your phone and the web can open it. Owner only; an HTML file under artifacts/, up to 4 MB, replacing the copy at that path. Private: only people who can read the discussion open it.

Allow one more ceiling's worth for this discussion — the “Keep going” on a stop at your own ceiling per discussion. Owner only; the team's ceiling is raised in Settings → Team. Answers with what is allowed in all and what has been spent.

?q=<the question>&exclude=<chat id> — the discussions you and your team started in the last 30 days that read like the question: id, title, who, when and a score, with the one line a new discussion is told. Plain word overlap, no model call. The Mac asks it before a discussion's first run; the server asks for itself on the web and the phone. Switched off by the account's “Point out a similar recent discussion”.

A seat reaching your other discussions, for the Mac's room. { op: "search", query, limit?, scope? } and { op: "open", id | key, maxChars? } read only what you could open yourself — your own and what your team shared with you, never a temporary one — as text to wrap as outside material. { op: "message", id | key, text, from: { id, key, title }, hop } sends a message into one you may write in: it starts that discussion's room, or joins its run, and answers delivered or queued. A chain of messages stops after two further hops.

Your teammates' discussions shared with your team, newest first: id, title, owner and their name, when it last changed, where it runs, whether its owner lets teammates drive it, whether it is running, and its ticket key and project. Your own are not in it, nor any in a project your team keeps you out of. With them, readOnlyReason (null when you may write, else why not — the team's plan ended, or you are an auditor) and notice (a pause that stops anything being sent). Open one with GET /api/chats/:id and write with /message or /comment.

{ "messageId": "…" } — put back the files an answer's run renamed on the Mac. The record of the renames is kept on that Mac, so this asks it, and it is woken to act; the answer's meta.fileBatch then says undone, or what was in the way. Owner only; refused with 409 while that Mac is offline or once the renames were undone.

{ "action": "stop", "job": "<id>", "step": "<id>" } — stop one of the discussion's background jobs on the Mac that runs it, or one step of it: a helper, a background command or a merge chain, as the Mac last reported them. The Mac is woken and stops it as its own Stop does. Owner only, and only for a job the Mac reported. GET on the same path answers with the jobs (background: clocks, model, tokens, step counts and the last steps) and which stops are still stopping.

{ "action": "pause" | "resume" | "stop" }, { "action": "merge_policy", "policy": "leave" | "merge_green" }, { "action": "budget", "usd": 25 } or { "action": "retry_task", "taskId": "<id>" } — steer the discussion's job: a big task its Mac split into sub-tasks and runs side by side for hours or days. The control is written down for that Mac, which is woken and acts on it; a control the job does not offer now (resume a running job, lower the budget, retry a task that did not fail) is refused with 409. Owner only. GET on the same path answers with the job as the Mac last reported it — status, budget and spend, deadline, merge policy and each task's state, branch and pull request — the controls still waiting, and whether you may press them. GET /api/jobs lists your jobs across discussions, active first (?active=1 for only those).

{ "command": "/loop 10m <what to check>" } or { "action": "stop" | "run-now" }, with "on": "mac" when the discussion is sent to its Mac — a prompt the discussion repeats on its own, every so often or at a pace its lead chooses, until the lead says it is done, it is stopped, it reaches the most runs the account allows, or a week has passed. A discussion the server runs loops at once; one a Mac runs is asked of that Mac, which is woken and acts on it as its own composer would. Owner only. Answers with a message, the loop as it stands, and how many asks are waiting for the Mac. GET on the same path, and GET /api/chats/:id as loop, carry it too.

{ "url", "key": "fix" | "merge" | "archive", "on": boolean } — switch one of an open pull request's switches: fix failing checks and review comments, merge when ready, or archive the discussion once it merges or closes. Nothing runs on the server. The Mac looking after the discussion is woken, acts on it under the same rules as its own menu (or refuses, if its owner turned that off), and reports back. Owner only; refused with 409 until a Mac has reported on the discussion, and with 403 where the team takes approvals on the Mac only. Answers with every open pull request's switches, a switch not yet acted on listed under waiting.GET /api/chats/:id carries the same list as prWatch.

?chatId= for one discussion's. Each run carries its state, spend, last steps, what waits for approval and, once a Mac has built it, build. Also: offer, the plan's cloud offer — on the free plan, its one trial run and whether it is available, running or used — and xcode, whether the discussion's project files hold an iPhone app the cloud cannot build.

{ "chatId", "objective", "model", "tokenBudget", "minutes", "dollars", "machine", "room" } — registered as your approval with this sign-in. On the free plan this is its one trial run: a small machine, a $1 ceiling and 30 minutes at most, and at least $1 of credit; anything more is refused with the reason.

{ "state": "built" | "failed" | "tests-passed" | "tests-failed" | "no-xcode" | …, "errors", "passed", "failed", "scheme", "branch" } — what the Mac reports after building a run's iPhone app on its cloud/… branch. Kept on the run and published on the discussion's live channel. Your own runs only.

The room as an agent another agent can call, over A2A. GET the same path — or /.well-known/agent-card.json — for the agent card: what the room does, where a task goes, and that a task needs a token. Then JSON-RPC 2.0: message/send hands the room a question and answers with a task at once, tasks/get says where that task has got to and carries the agreed answer as its artifact, and tasks/cancel stops it. The task runs as the account whose token carried it — its seats, its credit, its team's rules — and a refusal comes back as a failed task carrying the same sentence a person would have been shown.

One run as a picture: the seats with their turns, time and spend, the tool families each reached for, and a slice per turn in speaking order so a gap reads as time nobody was answering. Built from what the run already recorded, so a discussion with no run answers 404 rather than an empty drawing.

One run as a tree: its rounds, each seat's turn inside them, every tool call a turn made with what came back cut to size, and the discussions a turn delegated to as branches of their own. The same outline comes as lines, ready to paste, and as a one-sentence brief. Built from what the run recorded, so a discussion with no run answers 404.

A message sent while the room is answering joins the run at the next speaker's turn, rather than starting a second one. Until then it is waiting: { "queued": [{ "id", "content" }] }. Add "sendNow": true to the message body to interrupt the speaker who is mid-answer instead — they keep what they had said, and the discussion carries on.

Take a waiting message back before any seat has read it: { "messageId": string }. Once a speaker has been handed it, it is part of the discussion and the answer is404 — undoing it then is what rewinding is for.

Rename, move, pin, or set a discussion's depth: { "id", "title"? , "folderId"?, "pinned"?, "seats"?: 1–4, "rounds"?, "leader"? }.

Give a discussion its own room — who is in, who leads, and for each seat how it runs and which models it leads and reviews on: { "room": { "leader", "rounds"?: 0–6, "seats": { "claude"|"chatgpt"|"gemini"|"grok": { "enabled", "backend"?: "managed"|"free"|"api"|"custom"|"cli"|"acp"|"cloud", "model"?, "reviewerModel"? } } } } → { "room", "version", "by" }. The server numbers every change, and every device with the discussion open receives it as a room event on the live stream. A room chooses and never configures: commands, endpoints and keys are not accepted. GET on the same path reads it; room: null means the discussion follows the account's room. Author only.

Choose where a discussion's next message runs: { "runTarget": "here"|"mac" } → { "runTarget", "effective" }. here is answered on the server, on your account's seats — a seat the room runs on a Mac is your account's seat for that chair there; mac sends it to the computer the discussion runs on. Every device with the discussion open receives a run_target event on the live stream. GET on the same path reads it; runTarget: null means nobody has chosen, and effective is the default in force (a room with a seat only a Mac can run goes to the Mac). The author, or a teammate the author lets drive.

Delete a discussion, its messages, its reports and its share link.

A public read-only link: { "shared": true, "shareId" } → /share/:shareId. Body { "shared": false } withdraws it for good.

The audit log: every message, hash-chained, with a digest an auditor can recompute. Author only.

A note for the team that the room does not answer: { "content" } → { "id", "by", "byName", "at" }. It sits in the transcript where it was said, marked as a comment, and never reaches the models. Author or a teammate the discussion is shared with.

Fold the earlier turns into a note the seats read instead (row 256): no body → { "ok", "message": { "id", "speaker": "moderator", "content", "kind": "compact", "folded" }, "context": { "tokens", "window", "percent", "model", "canCompact" } }. Nothing is deleted — the folded turns stay in the transcript under the marker. Author only; refused while a run is writing (409), and when there is not enough to fold (400). GET returns the meter alone.

The side chat (row 257): { "passage"?, "question", "history"?: [{ "question", "answer" }] } → { "answer", "provider", "model" }. One seat answers a question about the discussion beside it, with the discussion so far and the passage in hand; nothing is stored and nothing enters the discussion. Anyone who may read the discussion may ask; the asker pays, as Ask does.

Compare, in a side-by-side discussion: { "round": 1 } → { "comparison": { "id", "speaker", "content", "round", "model", "label"? } }. The room's lead reads that round's answers and writes three short paragraphs — Shared view, Different bets, Still unanswered — added at the end of the transcript as a turn with role: "comparison" and the round it compares; asked again, a newer one is added and is the one shown. Anyone who may write the discussion may ask; the asker's lead answers and the asker pays, as for a run. Refused for any other kind of discussion, and for a round with fewer than two answers (400).

Combine, in a side-by-side discussion: { "round": 1 } → { "combined": { "id", "speaker", "content", "round", "model", "label"? } }. The room's lead merges that round's answers into one complete answer in Markdown: each item once, with the seats that gave it and the sources they cited, disagreements stated rather than settled, and nothing added. Saved at the end of the transcript as a turn with role: "combined" and the round it reads; asked again, a newer one is shown. The same gates, billing and refusals as Compare.

?message=…&n=… — one file a question was asked with, a picture or a PDF, whole: { "name", "mediaType", "data" }, the data in base64. message is the question's id and n the file's place among its files, as GET /api/sync lists them on the question (files: [{ "n", "name", "mediaType", "size", "text"? }], a PDF with its text and never the bytes). Anyone who can read the discussion; 404 for a file the question does not have.

Pin an answer, or take the pin off: { "messageId", "pinned": true|false } → { "ok", "pinned" }. The flag lives on the message and shows on every device — the Mac, the web and the phone each keep it in reach at the top of the discussion. Only an answer can be pinned, by the author or a teammate who may write to the discussion.

Who on the team a discussion is shared with: { "mode": "private" | "team" | "people", "emails"?: [...] } → { "mode", "people": [{ "email", "name" }], "team": [...], "teamName", "canChange", "shareBlocked", "inTeamProject" }. GET on the same path answers how it stands, to anyone who can read the discussion. Only the author, or the team's owner or an admin, changes it; only people on the team can be chosen; a new share needs the Team plan. Someone taken off loses access at once.

Run a new discussion on one of your computers: { "hostId" } (an id from GET /api/hosts) → { "hostId", "hostName", "noun": "Mac" | "PC" | "computer" }. The discussion becomes one that computer runs, as one started from Devices is; its next message goes there. Only before anything has been asked, only your own discussion, never a temporary one, and only to a computer checking in now — otherwise 409, with the reason.

Move a discussion to another of your computers, your Cloud Computer included: { "hostId" } (an id from GET /api/hosts) → { "status": "moved" | "handing_off" | "here", "hostId", "hostName" }. One not yet tied to a computer moves at once. One tied to a computer is handed over first: that computer commits the discussion's files as they stand to a branch of their own, pushes it to the repository's remote, and the new computer carries on from it; every device with the discussion open receives host_move events on the live stream. Only your own discussion, never while it is running, and only for a discussion in a git repository with a remote — otherwise 409, with the reason. Your own checkout and branches are not changed.

The other half of a move, for the LetThemBuild app only: the computer a discussion is on reports where it pushed the discussion's work, { "fromHostId", "remote", "branch", "head" }. Accepted only from the computer the discussion is tied to, and only with a remote address that carries no credential. A script has no use for it.

React to a message in a channel: { "messageId", "emoji" } → { "ok", "reactions": { "👍": ["you@…"] } }. Sending the same reaction again takes yours off. Only in a channel you may write to; at most eight kinds on one message.

Your bell for a channel: { "level": "all" | "mentions" | "off" | null } → { "ok", "level" }. all brings every new post to your Inbox, mentions only @mentions and replies in threads you are in, off nothing; null goes back to the default, mentions in a channel. It is yours alone and travels with sync.

Start a build session from a channel thread: { "thread" } (the post's message id) → { "id", "title", "key", "draft" }. It makes an ordinary In-turns discussion in the channel's project, with the thread as its description and draft as the words for its composer; it numbers the way any discussion there does. A thread that already has one returns it with existing: true. A channel itself never takes a ticket number.

Make a ticket from a channel thread, or from one message: { "thread" | "message", "draft": true } → { "title", "description", "drafted" }, a cheap model's draft (drafted: false when none could be asked, and the message's own words stand in). Then { "thread" | "message", "title", "description"? } makes it → { "id", "title", "key" }, with no run.

Say whether an answer was any good: { "messageId", "rating": 1 | -1 | 0 } → { "ok", "rating" }. 1 is a thumbs up, -1 a thumbs down, 0 takes the rating off; anything else is refused rather than rounded. Like the pin, it lives on the message and shows on every device, and it names the seat and the model that wrote the answer. Only an answer can be rated, by the author or a teammate who may write to the discussion. The reasons behind a rating go to POST /api/feedback with { "kind": "rating", "rating", "reasons": [], "details", "chatId", "messageId" }; reasons not on the list for that thumb are dropped rather than refused.

The ticket's activity, oldest first: created, every move of stage, type, priority, assignee, labels, components, release and project, with comments folded in — { "activity": [{ "actor", "actorName", "type", "text", "at", "detail" }] }. The ticket's own fields go through PATCH /api/chats: stage, issueType, priority, assignee, labels, components, releaseId, description.

The tables in an answer as a page with a done box and a note on every row. Body { "chatId", "markdown", "title"? } → { "id", "url": "/report/:id" }. Anyone signed in with the link can close a row: PATCH /api/reports/:id with { "rowId", "status"?: "open"|"closed", "note"? }; GET /api/reports/:id reads it.

What the account has spent, by provider and by discussion.

The agreed answer as a Word file: { "markdown", "title"? } → the .docx. A PDF needs no route: the answer and every report page print through the browser.

A web search, formatted to attach to a question: { "q" } → { "q", "results", "text" }. Only where the server is set up for it; GET says whether it is.

The one shape every client already speaks, on the account's own credit: Authorization: Bearer with an API key minted under Settings → API Keys. Body { "model", "messages": [{ "role", "content" }], "stream"?, "max_tokens"? }; the answer is OpenAI's. A Pro and Team perk for credit somebody already has, dearer than going direct by the margin taken when the credit was bought, and never Free Key's models. Refused without credit, and under the team's model and retention rules.

Body: a JSON-RPC request. Methods: initialize (protocol 2025-06-18; answers with the server's name and capabilities), tools/list, tools/call, ping; notifications get a 202. GET is 405 — there is no stream to subscribe to.

POST https://letthemchat.com/api/mcp                  (Authorization: Bearer … for tools/call)
{"jsonrpc":"2.0","id":1,"method":"tools/list"}
→ { "result": { "tools": [ { "name": "start_discussion", … }, { "name": "get_discussion", … }, … ] } }

{"jsonrpc":"2.0","id":2,"method":"tools/call",
 "params":{"name":"start_discussion","arguments":{"question":"Is a monorepo right for a team of three?"}}}
→ { "result": { "content": [{ "type": "text", "text": "Discussion started (id: …)" }],
                "structuredContent": { "discussion_id": "…", "status": "running" } } }

The eight tools. Three run the room:

• start_discussion { "question": string } — the room takes the question and works in the background; returns discussion_id at once. A plan past its limit, or an account with no provider connected, answers with isError and a sentence saying which.
• get_discussion { "discussion_id": string } — status (running, awaiting_input, agreed, error), the transcript so far, and — once the seats agree — the final answer, in structuredContent as final_answer. Poll it; a discussion takes one to several minutes.
• list_discussions {} — the account's twenty most recent, with their status.

Five answer what you would otherwise open the app to see. Each goes through the same code as the web routes, and the team ones through the same role check, so a connector can do nothing the account could not:

• list_running_rooms {} — discussions running now or active in the last two hours, newest first.
• spend_summary { "period"?: "today" | "week" | "month", "project"?: string } — spending by project, this week unless told otherwise; the account's own, or the whole team's for its owner, an admin or an auditor. project takes a key or a name.
• list_schedules {} — the account's schedules: what each runs, when, where (this server or one of its Macs), whether it is paused, and how its last run ended.
• run_schedule { "schedule_id": string } — starts a schedule now, as if its time had come. Only one that runs on this server; a schedule that runs on a Mac fires on that Mac.
• recent_audit_events { "hours"?: number, "limit"?: number, "type"?: string } — the team's last audit events, for its owner, an admin or an auditor. 24 hours back by default, up to 168; 50 events by default, up to 100.

Five reach the pull-request reviewer on the GitHub installations the account linked, or its team did:

• list_review_repos {} — where the reviewer is installed and linked, the repositories it covers, and whether reviews are on.
• list_pr_reviews { "repo"?: string, "pr_number"?: number, "limit"?: number } — the newest reviews, 20 by default, up to 50.
• get_pr_review { "review_id"?: string, "repo"?: string, "pr_number"?: number } — one review's state, confidence and findings, with links to its summary on GitHub and the discussion that wrote it.
• request_pr_review { "repo": string, "pr_number": number, "mode"?: "review" | "summarize" } — reviews an open pull request now, under the installation's switches and the paying account's limits; the review is posted on GitHub.
• ignore_pr_finding { "repo": string, "finding": string, "path"?: string, "reason"?: string } — settles a point for the repository, as replying ignore on GitHub does; for whoever linked the installation, or the team's owner or admins.

Every tool carries readOnlyHint, destructiveHint and openWorldHint.

A call without a valid token answers a result with isError and _meta["mcp/www_authenticate"], which is what makes ChatGPT open its connect flow. Twenty calls a minute per account.