← Back to comparison

Plan mode

Let your agent craft the perfect prompt for you.

Plan mode (also known as architect mode) is a multistep workflow where:

  1. The agent (LLM) creates a step-by-step plan for solving your task.
  2. The agent executes each step in the plan, one by one.

Why it works

Modern LLMs are now made to follow step-by-step instructions. You can see this in many press releases (like GPT-5.1 or Gemini), and in third-party tests like the Scale AI leaderboard.

Also, the Aider benchmark shows clear improvements in code quality when using architect (plan) mode.

There is no reason not to use this mode in your daily work.

Screenshot of plan mode: an agent generates a list of numbered coding steps, then executes each step in sequence, showing progress and task descriptions in a clear workflow.
Plan mode in Cursor. The agent splits a big task into steps, so you can check and agree with the plan before it runs.

Why it matters

How to use it

Cursor: open agent model and change “agent” to plan. You can also use Shift+Tab to rotate over the modes list

Codex: Not implemented

Junie: Not implemented

Claude Code: press Shift+Tab to choose a mode

Kilo code: just select “Architect Mode”

OpenCode: select “Plan Mode”. But you should switch into “Build Mode” when you complete the plan, and type “Implement” to execute the plan.

Multi-step Planning

Multi-step planning enables an agent to decompose a complex coding task into smaller, sequential steps before execution. Instead of attempting to solve everything at once, the agent creates a roadmap of actions.

Dual Model

Use different models for planning and execution.

Dual model lets you choose one AI model for planning and another for execution. This means you can use a smarter, more expensive model to plan the steps, but save money by using a cheaper model to carry out the tasks. Each model gets to do what it does best.

Advantages:

  • Save money by not using an expensive model for every step
  • Take advantage of different strengths—some models are better at planning, others at doing

Supported agents:

Not supported agents:

  • Codex (Not implemented)
  • Junie (Uses automatic model selection, not dual-model)

Not verified yet:

  • None

Questions

Let agents ask clarifying questions.

When writing out a task, it’s easy to overlook details or leave out important information. As humans, we make mistakes and have blind spots. Agents that ask clarifying questions can help identify these gaps in your instructions, making sure nothing critical is missed.

Screenshot of questions: an agent asks clarifying questions about the task.
Questions in Cursor. The agent asks clarifying questions about the task.

Supported agents:

  • Cursor (Just use Plan mode. Sometimes Cursor will ask you about`) features)
  • Kilo Code (The same as Cursor)
  • OpenCode (Prints questions at the end of each message)

Not supported agents:

  • Codex (Not implemented)
  • Junie

Not verified yet:

  • Claude Code

Plan Editing

Edit plans directly without running the model.

Make precise, targeted edits directly in the plan instead of running the model.

Sometimes we need to make changes to the plan. We could ask the model, “please, fix the plan: [proposed changes].” However, it’s often easier and more efficient to edit the plan directly rather than try to get the model to interpret your intended changes.

Supported agents:

  • Cursor (Available in plan mode - you can edit the plan steps directly in the interface before execution)

Not supported agents:

  • Codex
  • Kilo Code
  • Junie
  • OpenCode

Not verified yet:

  • Claude Code

Orchestrator Mode

Delegate complex tasks to specialized agents.

Plan Mode on steroids. The agent delegates each task to specialized agents, which allows it to achieve:

  1. Each agent has only the required context. Previous unrelated history doesn’t affect your task. For example, if you run tests in a cycle and have a lot of useless logs in the history, a new agent for the next edit task doesn’t see the test logs because they are not needed for editing.
  2. You can run agents in parallel if needed, because the orchestrator controls their execution area. For example: parallel fetching of information from the web.

Supported agents:

  • Kilo Code

Not supported agents:

  • Cursor
  • Codex
  • Junie
  • OpenCode

Not verified yet:

  • Claude Code

Todos

Track progress with auto-generated task lists.

You have to generate todo-list before plan execution to move the progress tracking from the model to your agent. It is useful for complex features because a model has no chance to skip any required step in the plan.

How it works:

When you build a plan and click execute. The agent creates a numbered list of subtasks that need to be completed. Each todo item represents a specific action or milestone in the implementation. As the agent executes the plan, it marks items as complete, giving you real-time visibility into progress.

Why it matters:

  • Agent forces a model to follow the plan step by step;
  • Agent can run some steps by himself without calling the model. For example: tests. If they are green, the agent don’t need to include the result into the context;
  • Clear visibility into what’s been completed;
  • Easier to review and approve before execution;
  • Agent can create checkpoints between steps for easy rollback if needed. You don’t need rollback all the work if some step was finished incorrectly.

Supported agents:

  • Claude Code (creates todos automatically when you execute a plan)
  • Cursor (creates todos automatically when you build a plan)

Partially supported agents:

  • Kilo Code (you need to explicitly ask it to create todos; not automatic. I recommend to write “create todos and execute” for Architect mode implementation)
  • OpenCode (you need to explicitly ask it to create todos; not automatic. I recommend to write “create todos and execute” for plan execution)

Not supported agents:

  • Codex (plan mode not implemented)
  • Junie (plan mode not implemented)