# Roundtable — full site content

> This file is the complete content of https://roundtable.sh as a single
> markdown document, for LLMs and AI agents. Source of truth: the site's own
> pages. A Frontier Infra project, MIT licensed.

---

# Roundtable

A council of frontier models — for the decisions that matter.

Roundtable is a command-line tool that convenes a council of frontier AI
models — Grok, Codex/OpenAI, GLM, MiniMax, Claude, and Gemini — answering in
parallel and optionally deliberating to consensus, so you get one decided
answer.

## Install (the four methods)

All four deliver the same engine:

- Installer (canonical): `curl -fsSL https://roundtable.sh/install.sh | bash`
- uv: `uv tool install roundtable`
- pip: `pip install roundtable`
- Homebrew: `brew install frontier-infra/tap/roundtable`

After install: `roundtable auth` to add provider keys, `roundtable doctor` to
verify, `roundtable ask "your question"` to convene the council.

## Six seats at the table

🤖 Grok · 🧠 Codex / OpenAI · 🟣 GLM · 🟠 MiniMax · 🔵 Claude · ✨ Gemini

Run as a one-round **advisory** panel, or as a chaired **deliberation** that
revises across rounds until a Claude chair declares consensus.

## Why convene a council?

A single model has a single set of blind spots. Roundtable seats up to six
frontier reasoners — each from a different lab, a different training run — so
the takes that matter are uncorrelated. When the decision is expensive to get
wrong, breadth beats a confident monologue: you see where the models agree,
where they split, and why. Roundtable then hands you one synthesized
recommendation instead of six tabs to reconcile by hand.

## How it works

Ask a question and Roundtable fans it out to every configured head in parallel.
In advisory mode (the default) each head answers blind — it never sees the
others — and you get every independent perspective side by side plus a
synthesis. In deliberation mode the heads run multiple rounds: after round one
each head sees the whole table and revises, while a dedicated Claude chair reads
the room and decides whether the council has reached consensus or should run
another round. Consensus ends it early; `--rounds N` is just the ceiling.

## Runs on your own keys

There is no hosted account, no SSO, and nothing to sign up for. Roundtable runs
on plain provider API keys you already hold — add at least one with
`roundtable auth` and the matching seat fills. Heads with no key skip
gracefully, so the council runs with whatever subset you have configured. It
also ships an MCP server (`roundtable mcp serve`) so coding harnesses like
Claude Code, Cursor, and the Codex CLI can call the council as a tool. Free and
open-source under the MIT license — a Frontier Infra project.

## Frequently asked questions

**What is Roundtable?** Roundtable is a free, open-source command-line tool that
convenes a council of up to six frontier AI models — Grok, Codex/OpenAI, GLM,
MiniMax, Claude, and Gemini — answering your question in parallel and optionally
deliberating to consensus, so you get one decided answer.

**Which models sit at the table?** Six heads: Grok (xAI), Codex/OpenAI, GLM
(Z.ai), MiniMax, Claude (Anthropic), and Gemini (Google). Each head is
optional — configure the keys you have and the council runs with whatever subset
is available.

**How do I install Roundtable?** Run the one-line installer
`curl -fsSL https://roundtable.sh/install.sh | bash`, or install with uv
(`uv tool install roundtable`), pip (`pip install roundtable`), or Homebrew
(`brew install frontier-infra/tap/roundtable`).

**Do I need API keys or local CLIs?** You need at least one provider API key.
Roundtable runs on plain keys with no hosted account or SSO. Where an
authenticated local CLI such as `codex` is present it is preferred, but no
vendor CLI is required.

**What is the difference between advisory and deliberation mode?** Advisory is
one round where each head answers blind and you get every independent take plus
a synthesis. Deliberation runs multiple rounds where each head sees the whole
table and revises until a Claude chair declares consensus.

---

# Get Started

Roundtable is a command-line tool that fans a question out to up to six frontier
model "heads" in parallel and hands you one decided answer. It runs on plain API
keys — no hosted account, no SSO.

## Install

Pick whichever fits your setup. All four deliver the same engine.

### Installer (recommended)

The canonical one-liner. Works on macOS and Linux:

```bash
curl -fsSL https://roundtable.sh/install.sh | bash
```

It checks dependencies (`bash`, `curl`, `python3`), drops the CLI into
`~/.local/share/roundtable`, and symlinks `roundtable` into `~/.local/bin`.
Re-running upgrades in place.

### uv

```bash
uv tool install roundtable
```

### pip

```bash
pip install roundtable
```

### Homebrew

```bash
brew install frontier-infra/tap/roundtable
```

If your shell can't find `roundtable` after install, add `~/.local/bin` to your
`PATH` and restart your shell.

## Authenticate

Roundtable needs at least one provider key. Run the guided prompt:

```bash
roundtable auth
```

It lists every provider with a ✓ (configured) or ✗ (missing), takes a masked
paste, and writes the keys to `~/.config/roundtable/config.env` (`chmod 600`).
Target a single provider with `roundtable auth <provider>`.

Recognized keys:

| Provider | Env var | Head |
|---|---|---|
| Anthropic | `ANTHROPIC_API_KEY` | Claude (and the chair) |
| OpenAI | `OPENAI_API_KEY` | Codex / OpenAI |
| xAI | `XAI_API_KEY` | Grok |
| Z.ai | `ZAI_API_KEY` | GLM |
| MiniMax | `MINIMAX_API_KEY` | MiniMax |
| Google | `GEMINI_API_KEY` / `GOOGLE_API_KEY` | Gemini |

Heads with no key (or no local CLI) skip gracefully — the council runs with
whatever subset you've configured.

Verify what's live:

```bash
roundtable doctor
```

## Ask the council

```bash
roundtable ask "Should we ship the migration today or wait for the staging soak?"
```

You get back a markdown transcript: each head's independent take, then a
synthesized recommendation. Narrow the panel with flags:

```bash
roundtable ask "Say OK in three words" --heads claude,gemini
```

---

# How it works

Roundtable has two modes. Both fan your question out to the configured heads in
parallel; they differ in whether the heads get to see and respond to each other.

## Advisory (default)

One round. Each head answers your question **blind** — it never sees the others'
responses. You get every independent perspective side by side, plus a
synthesized recommendation at the end.

Use it when you want breadth: diverse, uncorrelated takes on a decision, fast.

```bash
roundtable ask "What's the biggest risk in this rollout plan?"
```

## Deliberation

Multiple rounds. After round one, **each head sees the whole table** — every
other head's answer — and revises its own. A Claude **chair** reads the table at
the end of each round and prints a verdict:

- `VERDICT: CONSENSUS` — the heads have converged; the council stops early.
- `VERDICT: CONTINUE` — meaningful disagreement remains; run another round.

Use it when the decision is high-stakes and you want the models to actually
reconcile their disagreements rather than just vote.

```bash
roundtable ask "Postgres or SQLite for this workload?" --rounds 3
```

## The chair

The chair is a dedicated Claude seat that doesn't compete — it adjudicates. Each
round it summarizes where the table agrees, where it splits, and decides whether
another round is worth running. `--rounds N` is an upper bound; consensus ends
it sooner.

## Research mode

Pass `--research` to let heads that support tool use pull in fresh context
before they answer. Off by default — keeps runs fast and deterministic.

---

# The heads

Roundtable seats up to six frontier models. Each is independent — a different
lab, a different training run, a different set of blind spots. That diversity is
the point: a council of six uncorrelated reasoners catches what any single model
misses.

| | Head | Provider | Key | How it runs |
|---|---|---|---|---|
| 🤖 | Grok | xAI | `XAI_API_KEY` | Direct API (or an authenticated local CLI if present) |
| 🧠 | Codex / OpenAI | OpenAI | `OPENAI_API_KEY` | Direct API (or the local `codex` CLI if present) |
| 🟣 | GLM | Z.ai | `ZAI_API_KEY` | Direct API |
| 🟠 | MiniMax | MiniMax | `MINIMAX_API_KEY` | Direct API |
| 🔵 | Claude | Anthropic | `ANTHROPIC_API_KEY` | Direct API — also serves as the chair |
| ✨ | Gemini | Google | `GEMINI_API_KEY` / `GOOGLE_API_KEY` | Direct API |

## Configuring heads

Every head is optional. Configure a key and the seat fills; leave it blank and
the head skips gracefully — the council runs with whatever subset you have.

```bash
roundtable heads        # enable / disable heads interactively
roundtable models       # pick the model id used for each head
roundtable doctor       # show which heads are configured + reachable
```

Pick a subset for a single run with `--heads`:

```bash
roundtable ask "Review this API design" --heads claude,grok,gemini
```

## API keys, no CLIs required

Roundtable's heads run on plain API keys, so the full council works without any
vendor CLI installed. Where an authenticated local CLI is present (`codex`, a
logged-in Grok client), Roundtable will prefer it — but it's never required.

## The chair

Claude does double duty: it answers as a head and acts as the chair in
deliberation mode, adjudicating consensus. If you have an Anthropic key, you
have a chair.

---

# CLI reference

`roundtable <command> [args]`. With no command, `ask` is assumed —
`roundtable "question"` and `roundtable ask "question"` are the same.

## Commands

| Command | What it does |
|---|---|
| `ask "q"` | Convene the council on a question (default command). |
| `auth [provider]` | Configure provider API keys (masked paste → `config.env`). |
| `models` | Pick the model id used for each head. |
| `heads` | Enable or disable individual heads. |
| `doctor` | Show which heads are configured and reachable. |
| `config` | Show or edit `~/.config/roundtable/config.env`. |
| `mcp serve` | Run the MCP stdio server. |
| `mcp config` | Print the MCP server JSON block to paste into a harness. |
| `install` | Detect installed coding harnesses and wire Roundtable into each. |
| `update` | Upgrade Roundtable in place. |
| `version` | Print the installed version. |

## `ask` flags

| Flag | Description |
|---|---|
| `-q` | Quiet — print only the final synthesized answer, no per-head transcript. |
| `--rounds N` | Run a chaired deliberation of up to `N` rounds (default 1 = advisory). Consensus ends it early. |
| `--heads a,b,c` | Restrict the panel to a comma-separated subset (e.g. `claude,grok,gemini`). |
| `--research` | Allow tool-capable heads to gather fresh context before answering. |
| `-c` | Continue — include the previous question/answer as context. |
| `--out FILE` | Write the full transcript to `FILE`. |
| `--timeout S` | Per-head timeout in seconds. |

## Examples

```bash
# Quick advisory panel, final answer only
roundtable ask -q "Name one risk in this plan"

# Three-round deliberation, two heads, save the transcript
roundtable ask "Monolith or services for v1?" \
  --rounds 3 --heads claude,grok --out decision.md

# Let heads research before answering
roundtable ask "What changed in the latest spec?" --research
```

## Exit codes

`0` on a successful run. A non-zero exit means a hard failure (no heads
configured, all heads timed out). Individual heads that error or time out are
reported inline and don't fail the run as long as one head succeeds.

## Configuration

All settings live in `~/.config/roundtable/config.env` — a dotenv file,
`chmod 600`, sourced (not parsed) at runtime. For back-compat it also reads
`~/.api_keys` if present. Edit it directly or via `roundtable config`.

---

# MCP & harness install

Roundtable ships an MCP server as a subcommand of the same binary — no separate
package to install. Any harness that speaks the Model Context Protocol can call
the council as a tool.

## Run the MCP server

```bash
roundtable mcp serve
```

This speaks JSON-RPC over stdio and exposes one tool:

```text
roundtable(question, heads?, rounds?, research?)  ->  markdown transcript
```

A harness launches it with:

```json
{
  "command": "roundtable",
  "args": ["mcp", "serve"]
}
```

Print that block any time with `roundtable mcp config`.

## Auto-wire your harness

`roundtable install` detects the coding harnesses on your machine and wires each
one — idempotently. It backs up existing config first and never clobbers your
settings.

```bash
roundtable install                          # interactive: pick which to wire
roundtable install --harness cursor,codex   # wire specific harnesses
roundtable install --all                    # wire everything detected
```

Supported in v1:

| Harness | What gets wired |
|---|---|
| Claude Code | The Roundtable skill (`~/.agents/skills/roundtable/`) and the MCP server. |
| Cursor | MCP server entry in `~/.cursor/mcp.json`. |
| Codex CLI | `[mcp_servers.roundtable]` in `~/.codex/config.toml`. |
| generic | Prints the MCP JSON for you to paste anywhere. |

## Using it from the harness

Once wired, ask your assistant to "convene the roundtable" / "ask the council"
and it calls the `roundtable` tool, passing the question through. The transcript
comes back inline. All the `ask` flags map onto the tool's arguments (`heads`,
`rounds`, `research`).

---

# For AI agents

Roundtable is built to be operated by AI coding agents, not just humans —
Frontier Infra ships every project to be agent-installable ("eat our own
cooking"). If you're an agent reading this, here's the short path.

## Canonical guide

The authoritative, machine-readable install/configure/use guide lives in the
tool repository's `AGENTS.md`:
https://github.com/frontier-infra/roundtable/blob/main/AGENTS.md — it is the
source of truth. This page is a pointer and a quick summary.

## Quick path for an agent

1. Install — run the canonical installer:
   `curl -fsSL https://roundtable.sh/install.sh | bash`
2. Configure — write provider keys to `~/.config/roundtable/config.env`
   (dotenv, `chmod 600`) or run `roundtable auth`. At least one key is required.
3. Verify — `roundtable doctor` reports which heads are live.
4. Use — `roundtable ask "..."` for a transcript, or add `-q` for just the
   decided answer. Tune with `--heads`, `--rounds`, `--research`.
5. Wire into your harness — `roundtable install` auto-detects and configures
   Claude Code, Cursor, and Codex CLI; or use the MCP server directly via
   `roundtable mcp serve`.

## Machine-readable discovery

This site publishes agent-discovery surfaces at its root:

- `/llms.txt` — a concise, link-rich map of the site for LLMs.
- `/llms-full.txt` — this document: the full site content as one markdown file.
- `/agent.txt` — the Agent View Layer (AVL) manifest.
- `/.agent` and `/{path}.agent` — per-page agent views (text/agent-view; version=1).
- `/sitemap.xml` — generated by the site build.

Roundtable itself is the tool an agent should reach for when a decision benefits
from multiple independent frontier-model perspectives or a deliberation to
consensus.