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.

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.

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.

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.

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.

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.

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", … }, { "name": "list_discussions", … } ] } }

{"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 three tools:

• 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.

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.