Roundtable

Roundtable is a local desktop app for moderating one conversation across multiple AI coding agents.

It lets you bring Claude Code, Codex, and Gemini into the same project discussion, compare their answers side by side, ask targeted follow-ups, and approve tool calls before they touch your machine. The agents do not chat with each other directly. You decide when a round starts, which agents participate, and which tool requests are allowed.

Use it when you want a second or third model opinion without copying context between terminals.

What You Can Do

• Run the same prompt across Claude Code, Codex, and Gemini in parallel.
• Target specific agents with @claude, @codex, or @gemini.
• Review each agent's response in a shared round-by-round transcript.
• Approve or deny tool calls from the UI.
• Import prior CLI sessions from ~/.claude, ~/.codex, and ~/.gemini.
• Keep all Roundtable conversation state on your machine.

Roundtable is an orchestration layer. The actual model access, authentication, billing, and provider-specific behavior still come from the official agent CLIs.

Roundtable invokes the installed agent CLIs on your machine. Before using it, make sure your use of Claude Code, Codex CLI, Gemini CLI, or any other configured tool is allowed by that tool's terms, account policy, and workspace policy. This has not been a practical issue in normal use, but you should make your own call for your environment.

Project Status

Roundtable is v0.1.0 and early.

The app has been tested on macOS Apple Silicon. Windows x64 and Linux x64 builds are produced in CI, but they have not been smoke-tested. Expect rough edges on those platforms. Bug reports and small fixes for non-Mac platforms are especially useful right now.

See the Releases page for published builds.

Requirements

Install at least one supported agent CLI before using Roundtable:

Agent	CLI	Install
Claude	claude	https://claude.ai/download
Codex	codex	https://github.com/openai/codex
Gemini	gemini	https://github.com/google-gemini/gemini-cli

You can use any subset of these agents. Missing CLIs are shown as unavailable in the app.

Install

Download the package for your platform from the latest release:

• macOS Apple Silicon: download Roundtable-macos-arm.zip, unzip it, and drag Roundtable.app into /Applications.
• Windows x64: download Roundtable-windows-x64.exe and run it.
• Linux x64: download Roundtable-linux-x64.tar.gz, extract it, and run the launcher inside.

The macOS app is signed and notarized. The Windows executable is signed through Azure Trusted Signing.

Windows Package Manager

WinGet support is planned after the manifest is accepted into microsoft/winget-pkgs.

winget install deadbeef101010.Roundtable

Run From Source

Roundtable uses Bun, Vite, React, Hono, and Electrobun.

git clone https://github.com/deadbeef101010/roundtable.git
cd roundtable
bun install
bun run dev

bun run dev starts the backend on port 3001 and the Vite frontend on port 3000.

For the desktop shell:

bun run dev:desktop

Useful development commands:

bun test
bun run test:e2e
bun run build:desktop
bun run build:binary

Data And Privacy

Roundtable stores conversation data locally under:

~/.roundtable/

That directory contains transcripts, shared plan and memory files, imported session metadata, agent session IDs, and logs. Set ROUNDTABLE_HOME=/path/to/dir to use a different location.

Roundtable does not provide model inference itself. When an agent runs, that agent's official CLI or SDK may send prompts, files, tool results, and other context to its provider according to that provider's behavior and your CLI configuration.

In short: Roundtable's own state is local, but the agents you invoke may still call Anthropic, OpenAI, Google, or other services through their normal CLIs.

How It Works

Roundtable has three main pieces:

• A React frontend for conversations, settings, session import, and tool approvals.
• A Bun/Hono backend that manages conversations, WebSocket events, local persistence, and agent orchestration.
• Agent adapters for Claude Code, Codex, and Gemini.

On each round, the orchestrator sends the user's message to every active or targeted agent. Each agent also receives the other agents' completed responses from the previous round. Agents do not receive a live stream of each other's current responses, and they do not send messages directly to each other.

Tool requests flow back through Roundtable so the moderator can approve or deny them from the UI.

For more detail, see docs/ARCHITECTURE.md.

Typical Workflow

Roundtable works best when the user stays in the moderator seat.

You can ask all active agents the same question, compare their answers, and then decide what happens next. You can also route a round to only one or two agents. For example, you might ask Codex to draft an implementation plan while Claude waits out that round, then ask Claude to critique the plan in the next round.

Directed messages use these agent names:

@claude
@codex
@gemini

Single-line Directed Messages

Put the agent mention at the start of a line:

@claude critique this plan for missing edge cases

If the message contains only directed lines, only those agents receive the round. Unaddressed agents do not run that round. They will see the completed exchange as prior context the next time they are addressed.

You can address multiple agents in one round:

@codex write a concrete implementation plan
@gemini look for simpler alternatives

Multiline Directed Messages

For multiline instructions, use a fenced block labeled with the agent name:

```codex
Write the implementation plan.
Include files to change, tests to run, and risks.
```

You can mix broadcast text with directed blocks:

We are deciding how to ship this feature.

```codex
Write the plan.
```

```claude
Wait this round unless you see a serious architectural risk.
```

Broadcast text outside directed lines or blocks goes to every active agent. Directed content goes only to the addressed agent.

Repository Layout

src/server/          Backend, orchestrator, adapters, storage
src/web/             React frontend
src/bun/             Electrobun desktop entrypoint
test/unit/           Unit tests
test/e2e/            End-to-end tests
docs/ARCHITECTURE.md Architecture notes

Contributing

Roundtable is intentionally small. Focused PRs are easier to review than broad rewrites.

Good first contributions include:

• Linux and Windows smoke-test reports.
• Reproducible bugs with logs from ~/.roundtable/logs/.
• Adapter fixes for CLI protocol changes.
• Tests around orchestration, session import, and tool approval behavior.
• Documentation that helps users understand setup, privacy, or platform-specific issues.

Read CONTRIBUTING.md before opening a PR.

Related Project

Roundtable Pro is a hosted web version with extras such as automatic model-to-model discussion before results are surfaced to the user. It uses a separate codebase and is available at roundtable.deadbeef101010.com. This repository is for the local desktop app.

License

MIT © 2026 Hitesh Patel