Model Council

Ask ONE member of the council a question and return its answer. `model` is the member's short id; the schema lists the ones this council has, and `list_council` describes them. The member is stateless and cannot see this conversation, so `prompt` must carry everything it needs — including any other model's answer you want it to critique. Optionally set `system` to steer its role or output format. `materials` hands the council the thing the question is about — a spec, a log, a diff, a screenshot — instead of you pasting it into `prompt`. Give `{path, label}` for a file, or `{text, label}` for something with no file behind it. Prefer a path: the members are then handed the file's exact bytes rather than your reproduction of them, you do not spend a copy of the whole document writing this call, and every member and every round get an identical copy, which is both what makes their answers comparable and what an endpoint's cache can match. Images go this way too, and are the case that matters most: describe a screenshot in prose and every member inherits the same description, so anything you misread is misread by the whole council at once.

Ask several members the SAME prompt in parallel, returning their answers side by side and labeled by model. By default every configured member answers. Pass `models` to ask only some of them; the schema lists the valid ids. `rounds` (1-3, default 1) runs a real discussion. With `rounds=2` the members first answer independently, then each is asked again — this time carrying the question plus every answer from round 1, its own and the others', verbatim — and asked to revise. Members are stateless, so carrying the previous round back to them is the whole mechanism: without it a second round is just the same question asked twice. The transcript returns round by round, so you can see who moved and who held their ground. One round is a survey of opinion. Two is worth the extra latency and tokens when the answers are likely to disagree and the disagreement is the interesting part. `rounds` is chosen before anything has been asked, which is the one thing wrong with it: you commit to a second round without having read the first, and a council that turns out to agree costs exactly what one still arguing would. When you would rather look first, ask with `rounds=1` and then call `revise` with the answers — it runs one more round on demand, as many times as you judge it worth, and it has no ceiling. Reading before you buy is usually the cheaper of the two: one more round is another full call per member, while `revise` costs you only the answers written back into it. `guests` seats answers you already have. If you spawned a subagent on this same question, or formed your own view first, pass it here as {label, text} and it joins the table: it appears in round 1 beside the members, and from round 2 the members are shown it verbatim and argue with it. This is the difference between an answer that is in the discussion and one that is merely next to it — without it, the models never learn your subagent had an opinion. Pass the text verbatim, not a summary; a summary is not what…

List the council's members: their ids, labels, target models, weights, wire format, endpoint, call budget, and whether each one is ready to answer. `weight` is how much this council trusts each member, relative to the others; everyone is 1 unless the roster says otherwise, and `ask_all` reports it alongside the answers whenever they differ. `tries` is how many attempts a call gets and how long each may take, so a member that is slow or that keeps being retried is visible here. `sees` is whether this member may be shown an image in `materials`. The line above the table says whether this server will read `materials` paths at all, which depends on how its operator runs it. `route` is how this member reaches its endpoint — `env` follows the proxy in the server's environment, `direct` ignores it, and a URL is a proxy set for that member alone. It appears only when the members can differ; passwords in a proxy URL are masked. A member may have `backups`: further endpoints for the same seat, indented under it as `↳ backup 1`, `↳ backup 2` and tried in that order when the one above does not answer. They are the same member — same id, same label, one vote — so you never address a backup directly; the seat's id reaches whichever of them is up. Read their `model` column: a backup is often the same model under a different id, and sometimes not the same model at all, and `ask_all` names the one that actually answered above each answer. Cheap and local — makes no network calls. Use this to find out which ids you may pass to `ask` and `ask_all`, or to explain a configuration problem.

Ask a member's endpoint which model ids it actually exposes, by calling its /models route. Pass `model` to probe one member, or omit it to probe every configured member. Use this when a call fails with an unknown-model error, or to discover what else a provider offers — model ids move fast.

Run ONE more round of an existing discussion: show every member what was said last round and ask it to revise. This is `ask_all`'s rounds turned inside out, so that you can drive them. Two reasons to want that. **You would rather decide after reading.** `ask_all(rounds=2)` commits to the second round before the first one exists. Ask with `rounds=1`, read what comes back, and call this only if the disagreement is worth another call per member — or call it three more times if they are still moving. There is no round ceiling here, unlike `ask_all`, because every round is one you chose to pay for. **A voice in the discussion is one only you can produce** — a subagent you spawned, or your own answer — and you want it to be a full member rather than a one-off: something that answers, reads the others, and revises alongside them. The loop, in the second case: 1. `ask_all(prompt)` — the members answer round 1 ...and you produce your subagent's round-1 answer yourself 2. `revise(prompt, answers=[...])` — pass EVERY round-1 answer, the members' and your subagent's; the members come back revised ...and you re-run your subagent on the same material 3. repeat as long as it is still moving Each entry in `answers` is `{text, model}` for a member's own answer, or `{text, label}` for an outside one. Naming the member matters: that is what lets it see its previous answer as its own and revise, instead of answering fresh. `round` is which round the answers you are passing came from, so the members are told where they are. Pass answers verbatim, never summarised. Pass the same `materials` you passed to `ask_all`, every round. The members are stateless: a document they were shown last round does not exist for them in this one, and a council revising from memory it does not have will revise from the other answers alone.

Build the exact prompt a seat should be given for the next round — for the one seat this server cannot ask itself: yours. `revise` asks the members. Your subagent is yours to re-run, and how you prompt it decides whether it revises at all: handed the original question again, it will reproduce its previous answer, and nothing in the transcript will show that the seat stopped participating. Handed this, it revises on exactly the terms the members did — same framing, same instruction to hold a position it still believes against the majority, which is the sentence that keeps a council from collapsing into agreement. Pass the same `prompt`, `answers`, `round` and `materials` you are passing to `revise`, plus `seat`: the label (or member id) of the seat to write for. Cheap and local — makes no network calls, so run it alongside `revise` rather than after it. Material is named in the prompt rather than pasted into it, at the position the members were given it. Open those files for your seat before you hand it the rest: a seat that revises without the document is arguing about something it has not read, and the transcript will not show it.