Skip to main content

Driving your AI agents in ECO mode

Planning and implementing are not the same kind of work. Planning needs a strong reasoning model that explores the codebase and weighs options. Implementing a clear, approved plan is mostly mechanical, and a cheaper, faster model can handle that.

Picking one model for everything is not a good idea. You either overpay for the build, or you underpay for the plan. A colleague recently pointed out that JetBrains AI can split this, and it turns out Copilot can do something similar. Let’s look at both.

Plan and build in VS Code

The Plan agent in VS Code has its own model setting. Two settings matter:

{
  "chat.planAgent.defaultModel": "<planning model>",
  "github.copilot.chat.implementAgent.model": "<implementation model>"
}


  • chat.planAgent.defaultModel is the model used by the Plan agent.
  • github.copilot.chat.implementAgent.model is the model used when you click Start Implementation.

Prefer to do it by hand in a Copilot session? Pick the planning model in the model picker, ask for a plan and choose Approve Plan Only. Then select the implementation model, switch from Plan to Interactive and ask the agent to implement the approved plan in the same conversation.

There is an even simpler way. Pick a frontier model in the Chat view, and name the build model in your prompt:

Create a plan to add caching to the ProductService. 
Once the plan is ready, hand the build over to GPT-6 Luna.

The agent makes the plan and delegates the implementation to the second model.

Tip: The same approach works in the GitHub Copilot app and Copilot CLI.

Let Copilot choose: Fusion

What if you don’t want to decide which model does what? That’s what Copilot Fusion is for. It started as Project HydraFusion in Copilot CLI and became generally available on 28 October 2026.


Instead of a model, you select Copilot Fusion in the model picker and choose an effort level: Standard, High or Max. Copilot then picks a workflow for each prompt:

  • Single: one model answers directly
  • Cascade: work is routed through different models
  • Critique: one model drafts and other models review it

So selecting Fusion does not mean multiple models run every time. Billing is per model at its standard rate, and there is no extra charge for the orchestration itself. Paid plans get a temporary 30% discount on model costs until 30 November 2026.

Remark: High and Max are not available on every plan, and your organization’s model policies still decide which models Fusion can use.

And in JetBrains?

The JetBrains answer is called Junie Eco mode. The model you selected acts as the architect: it studies the code and writes a plan. A much cheaper model (currently GPT-6 Luna) acts as the builder and implements the plan.

A few things to know:

  • Eco mode is on by default for supported model and effort combinations
  • It only kicks in for tasks that require code changes
  • It is available in JetBrains Air in IDEs: 2026.2 versions and IntelliJ IDEA 2026.3 Beta

If you prefer the terminal, Junie CLI has an Advanced Plan Mode that writes plans to .junie/plans, and JetBrains pitches it as “plan on Opus, implement on Flash”.

And because Fusion is also available in JetBrains IDEs, you can use it there as well.

Which one should you use?

  • Manual split in VS Code: you want to choose the planning and build models yourself
  • Fusion: you want Copilot to decide, and you accept that the cost is less predictable at High and Max
  • Junie Eco mode: you live in a JetBrains IDE and want the architect/builder split without configuring anything

Whatever you choose, review the plan before you start the build. A cheap model implements a bad plan just as fast as a good one.

That’s it!

More information

Labels:

Popular posts from this blog

Podman– Command execution failed with exit code 125

After updating WSL on one of the developer machines, Podman failed to work. When we took a look through Podman Desktop, we noticed that Podman had stopped running and returned the following error message: Error: Command execution failed with exit code 125 Here are the steps we tried to fix the issue: We started by running podman info to get some extra details on what could be wrong: >podman info OS: windows/amd64 provider: wsl version: 5.3.1 Cannot connect to Podman. Please verify your connection to the Linux system using `podman system connection list`, or try `podman machine init` and `podman machine start` to manage a new Linux VM Error: unable to connect to Podman socket: failed to connect: dial tcp 127.0.0.1:2655: connectex: No connection could be made because the target machine actively refused it. That makes sense as the podman VM was not running. Let’s check the VM: >podman machine list NAME         ...
Read more

Cache stampede: when our cache turned against us

While investigating some performance issues, we ran into an ASP.NET Core API that cached a fairly expensive aggregation query for 60 seconds. Under normal load, that was fine: one request rebuilds the cache, everyone else reads from it. Under peak load, dozens of requests would arrive in that same expiry window, all see a cache miss, and all fire the same expensive query in parallel. The database didn't like that. That was the moment when our caching layer stopped helping and started hurting. A burst of requests comes in at the same time, all miss the cache, and all go hammer the database or the downstream API at once. That's a cache stampede . The cache was supposed to protect our backend, and for a few hundred milliseconds it did the opposite. Why this happens IMemoryCache.GetOrCreate (and its async sibling) looks like it protects you, but it doesn't add any locking on its own. Look at the naive version: public async Task<Report> GetReportAsync(string key) ...
Read more

VS Code Planning mode

After the introduction of Plan mode in Visual Studio , it now also found its way into VS Code. Planning mode, or as I like to call it 'Hannibal mode', extends GitHub Copilot's Agent Mode capabilities to handle larger, multi-step coding tasks with a structured approach. Instead of jumping straight into code generation, Planning mode creates a detailed execution plan. If you want more details, have a look at my previous post . Putting plan mode into action VS Code takes a different approach compared to Visual Studio when using plan mode. Instead of a configuration setting that you can activate but have limited control over, planning is available as a separate chat mode/agent: I like this approach better than how Visual Studio does it as you have explicit control when plan mode is activated. Instead of immediately diving into execution, the plan agent creates a plan and asks some follow up questions: You can further edit the plan by clicking on ‘Open in Editor’: ...
Read more