Plan with a SOTA model. Build with cheaper workers in parallel.

When to use this pattern#

Use this when a complex task would take too long to complete sequentially. The coordinator needs to be able to divide it into parts the workers can implement independently.

Why this division of work helps#

• Give cheaper models clearer tasks. The coordinator works out how the pieces fit together before implementation starts. Workers get smaller tasks with defined interfaces and dependencies.
• Use different subscriptions and providers. Planning and review use the SOTA model. Workers can use a subscription with more quota or a cheaper API, each through its own CLI and provider.
• Finish sooner with parallel work. Independent tasks run at the same time instead of one after another.
• Give each worker its own files. Git worktrees provide separate working directories, so workers can edit independently. Their changes are then merged and checked together.

1. Start the coordinator#

• Open your project in the editor.
• Start from a clean working tree, with no uncommitted changes, so the new worktrees share a known starting point.

The table shows one example setup. You can use other installed CLIs and models available to your accounts.

In your project, open Facade, click New Agent, and choose Codex for the coordinator. Use /model to select gpt-6-sol and xhigh effort.

You only need to start the coordinator manually. It launches the other agents for you through Facade. If this is your first time using Facade, check out the quickstart.

2. Send your task#

Send this prompt to the coordinator, replacing the first line with your task and any architectural constraints:

[Describe your task and the expected result.]

First, draft a technical plan. Once I approve it, create an execution plan that breaks the work into parallel tasks.
Use Facade to start a worker with deepseek-v4.1-flash and xhigh effort in a separate worktree for each task.
Have the workers implement and test their tasks in parallel, then coordinate their merges back into this working tree one at a time.
When all changes are merged, review the combined code and run the test suite.

3. How the team works#

1. Approve the technical plan
2. Create the execution plan
3. Implement tasks in parallel
4. Review and test the combined changes

1. The coordinator reads the codebase and proposes a technical plan covering the architecture, interfaces, and task boundaries. You review it before implementation starts.
2. After approval, it creates the execution plan and uses Facade to start workers in separate Git worktrees.
3. Workers implement their tasks in parallel and run the relevant checks. They merge back one at a time. The coordinator helps resolve conflicts before the next merge.
4. The coordinator reviews the combined code, runs integration tests, and reports the results and anything still unverified.

Use it in your project#

• Let the coordinator choose the number of workers based on how the task can be divided.
• Discuss changes to the architecture or task boundaries before approving the technical plan.
• Add your provider endpoint in Agent settings. You can use DeepSeek through Codex, Claude Code, Pi, or OpenCode.

You can change the CLIs, models, and effort in the prompt. For saved launch settings and other providers, see Agent settings, Claude Code with another provider, and Codex with another provider.