How it works.
Six ways to get outputs from the best models, end-to-end. Pick the one that fits how you’re thinking.
One model, one fast output.
The fast lane. Pick a model, type a question, get an output. No ceremony — for when you know which model you want and you just need it to work. Supports text and image attachments.
How it works
- 1Pick a model from the picker (top of the thread).
- 2Type your message. Attach files or images via the paperclip if you need to.
- 3Press Cmd+Enter — the output streams in.
- 4Continue the conversation; the model sees prior context.
Three perspectives, one decision.
The same prompt goes to three different models in parallel. Free tier: read all three drafts side-by-side and decide for yourself. Plus tier: the models critique each other across multiple rounds, then a synthesizer you pick integrates the strongest insights into one definitive output.
How it works
- 1Pick the Multi AI workspace tab in the sidebar.
- 2Round 1 — three drafts (Claude / GPT / Gemini) stream in parallel.
- 3Plus tier · Round 2 — each model reviews the OTHER two drafts and writes a structured critique.
- 4Plus tier · Round 3 — pick the synthesizer; they integrate the strongest outputs + critiques into a single response with attributed influences.
- 5Show thinking toggle reveals the drafts + critiques after synthesis if you want to audit.
Reasoning plans. Coding builds. Design refines.
A specialist-role orchestrator where each role uses the model that's best at it. Three roles you assign — Reasoning, Coding, Design — with sequential routing decided by the Reasoning model on the first pass. The user-chosen Reasoning model gets the first and last say; downstream specialists run only when needed.
How it works
- 1Pick the Cowork workspace tab in the sidebar.
- 2Optionally swap the model for any role via the per-role picker (defaults: Haiku 4.5 for Reasoning, GPT-4o-mini for Coding, Gemini Flash-Lite for Design).
- 3Send your prompt — Reasoning runs first, breaks down the task, and emits a JSON signal with requires_code / requires_design flags.
- 4Coding runs only if requires_code=true; Design runs after Coding (refining CSS) or directly from the spec when CSS isn’t involved.
- 5Reasoning runs once more as Final Review — closing summary that integrates everything the specialists produced.
- 6Skipped roles render as a small pill so you understand the routing decision at a glance.
A multi-round deliberation layer on top of any mode.
A toggle below the composer. When on, the model team doesn’t just answer — they deliberate. In Multi AI, an arbiter reviews the synthesis as a final oversight pass. In Single and Cowork, three models draft, critique each other, respond to the critiques of their own drafts, then the arbiter reads the full transcript and writes the definitive output. The arbiter is dispatched per tier so every plan gets the deliberation experience.
How it works
- 1Toggle Advanced Thinking on (composer footer, next to Send).
- 2In Multi AI: Round 1 drafts run, you pick the synthesizer, then the arbiter reviews the synthesis and writes a final verdict.
- 3In Single or Cowork: pick three slot models. Round 1 — drafts. Round 2 — each model critiques the other two. Round 3 — each model responds to the critiques of its own draft.
- 4Round 4 — the arbiter reads the entire transcript and writes the definitive output. Verdict streams in.
- 5The transcript is preserved — you can re-open the rounds in the thread to audit how the team got there.
Drop in files and images.
Text files inject into the model’s system prompt. Images pass natively as vision content to every model in the call. Works in every mode — Single, Multi AI, Cowork, Advanced Thinking all read the same attached files.
How it works
- 1Click the paperclip in the composer (or drag-drop onto it).
- 264KB per file, 256KB per conversation total. Allowlist: jpeg / png / gif / webp images and txt / md / ts / tsx / js / jsx / py / json / csv / html / css text files.
- 3Each attachment renders as a chip with hover preview (image thumbnail or first-line for text).
- 4Click the folder button next to the paperclip for a full file panel — names, MIMEs, sizes, batch remove.
- 5Send — every model in the call reads the files alongside your prompt.
Tier-split autonomous agent.
An autonomous agent that takes a task, executes inside a secure sandbox, and delivers the result — not just a transcript. The flavour scales with your tier: Free and Plus get a single-agent Forge that escalates blockers back to you; Pro gets the full three-model debate where every action is debated, a synthesizer decides, and Cowork-style role routing picks the specialist for each subtask.
How it works
- 1Pick your task and (Pro only) the three models who should pick the definitive output.
- 2Free & Plus: one model takes the brief, reasons through the next step, executes inside the sandbox, and reviews the result before moving on. Blockers escalate back to you for a decision.
- 3Pro: before any non-trivial step, three models propose distinct positions on what to do next. A synthesizer locks the decision; Cowork-style role routing picks the specialist for the subtask.
- 4Sandbox executes — browser navigation, code with iteration loops, file output — all inside an ephemeral compute environment that can’t touch your machine.
- 5Loop-back deliberation after each action. Failed actions trigger a new deliberation round, not a blind retry.
- 6Final delivery — the files, the result, the audit log. Everything visible and replayable in the thread.
Pick a mode and start.
Free to start. No credit card required.