Plan first. Then orchestrate.
Most multi-agent coding tools skip straight to execution. Spawn a few terminals, type a prompt into each one, hope for the best, and merge by hand. That approach gives you parallelism, but not orchestration.
Plexus starts where the others don't: with a plan. Whether you prefer structured specifications or freeform conversation, Plexus gives you a dedicated planning phase that flows naturally into coordinated multi-agent execution. No IDE required, no fork of anything. Just a native macOS app that does one thing well.
Every project in Plexus begins in Plan mode. You choose the workflow that fits:
Simplex Spec. Natural language prompts are ambiguous. Simplex is the antidote: a specification language optimized for high-fidelity interpretation by LLMs. It captures what needs to be done and how to know when it's done, without prescribing implementation. Landmark-based syntax (FUNCTION, RULES, DONE_WHEN, EXAMPLES) gives autonomous agents the precision that prose alone cannot provide, and inline examples serve as binding contracts between your intent and the agent's output. Plexus lints your spec in real time and tells you when it's ready. When it is, every function becomes an autonomous agent task.
Conversational. Talk through the problem naturally. Explore architecture, debate tradeoffs, and iterate on scope. The system keeps the conversation focused on planning without letting the LLM jump ahead to implementation. When you're ready, hit Orchestrate and Plexus decomposes your conversation into coordinated tasks automatically.
Both workflows hand off to the same orchestration engine. The planning phase is what makes the orchestration intelligent.
When Plexus orchestrates, every agent task runs in its own git worktree. Agents cannot step on each other or corrupt your working copy. They don't know the others exist, but the orchestrator does.
Failed agents retry with escalating context. Passing agents merge back to a dedicated orchestration branch automatically. Your checkout is never touched until you decide to bring the changes in. This is selective merging, where only completed and passing work flows back, not a pile of diffs to review one by one.
While agents work, a live coordinator chat gives you a direct line to the orchestrator. Ask what's happening, redirect a task, or just watch the progress stream in real time.
Plexus supports Claude Code, Codex, and Cline as execution backends, and lets you mix them freely.
Use Claude with Opus for complex orchestration tasks. Use Sonnet for fast planning iterations. Use Codex for the orchestrated agents while planning with Claude. Plan and Orchestrate each get their own independent agent and model selection. Claude Code works with both Max subscriptions and API keys.
Plexus includes an integrated terminal with first-class tmux support. Your existing tmux configurations, sessions, and workflows carry over naturally. Preset terminal tabs for Claude Code, Codex, and shell are ready out of the box, and the terminal is a real terminal, not a sandboxed imitation.
The tools in this space each got part of the picture right.
Kiro introduced spec-driven development to a wide audience, but it only supports a spec-first workflow. There's no path from a freeform conversation to structured execution. Small tasks get buried under user stories and acceptance criteria. And specs are one-shot with no mechanism for evolution, iteration, or multi-agent execution.
Conductor and Superset showed that developers want to run multiple agents at once. But they are multiplexers, not orchestrators. Each agent gets a prompt and works alone with no decomposition, no dependency awareness, and no coordinated merging. The user becomes the orchestrator.
Google's Jules had the right idea with an agent manager, but it lives inside a VS Code fork. You adopt their entire IDE or you don't use it at all. Plexus was built to be what that agent manager should have been: a focused, standalone tool that coordinates coding agents without dragging an editor along with it.
Plexus occupies the space between all of them. Structured specs when you want rigor, conversational planning when you want flexibility, and true orchestration either way, with worktree isolation, selective merging, live coordination, and the freedom to bring whatever agents and models you prefer.
No cloud, no accounts, no telemetry. Plexus is a native macOS app backed by a local Go process. Your code is shared only with the model providers behind the agents you choose to use.
Plexus is under active development.