Match Effort To Task Size

If every agent session you open is set to maximum reasoning effort, you're paying the same tax for "which languages does this codebase use" as you are for "scope out five potential new features." One of those is a five-second lookup. The other genuinely needs the agent to explore, weigh trade-offs, and think. Treating them the same means the quick question waits in line behind the slow one.

The problem: one effort level for every task

Most coding agents expose some notion of reasoning effort or model tier — a knob that trades latency for depth of exploration. Left on "high" by default, every session pays for deep reasoning whether the task needs it or not. A quick lookup that could return in seconds instead takes minutes, because it's using the same budget as a task that has to explore the whole codebase and propose options.

The inverse mistake is just as costly: dropping every session to low effort so things feel fast, and then getting a shallow answer on a task that actually needed the agent to dig.

Match the session to the task

Run a handful of terminals or sessions at once, and set the effort level per session based on what that specific task needs:

• High effort: work that requires exploration or judgment — "scope out five potential new features" needs the agent to survey the codebase and reason about trade-offs before answering.
• Low effort: narrow, factual lookups — "which languages are used in this codebase" doesn't need deep reasoning, just a fast scan.
• Medium effort: the middle ground — tasks with some ambiguity but a bounded scope.

In practice this looks like four terminals running side by side: two on high effort for the exploratory work, one on medium, one on low for the quick lookup. The low-effort session comes back with its answer while the high-effort ones are still working — you're not blocked waiting on the slowest one to get to the question you could have already answered.

How to run it

1. List out what you actually need answered or built right now.
2. Sort each item by how much exploration or judgment it genuinely requires.
3. Open one session per task.
4. Set the effort or model tier per session — high for the exploratory or creative work, low for quick lookups, medium for everything in between.
5. Route each task to its matching session and let them run concurrently.

The gain isn't just speed on the easy tasks — it's that the hard task also gets the deep thinking it needs, uninterrupted, instead of being rushed through at a shared low setting to keep everything else responsive.

The limit: parallel sessions have a ceiling

Running sessions in parallel doesn't scale indefinitely. There's a practical ceiling on how many concurrent streams a person can actually track and review — roughly four at a time before you're just skimming and missing things. Past that point, adding more sessions doesn't add throughput, it adds sessions you'll forget to check on.

Power tricks

• Watch context, not just effort. As a long-running session's context window fills up, responses start to drift — the agent loses track of earlier decisions or repeats itself, regardless of effort level.
• Clear or compact before drift sets in. Don't let a high-effort session run indefinitely on an increasingly bloated history — clear or compact it proactively.
• Reserve max effort for genuinely open-ended work. If a task has a bounded, factual answer, it doesn't need the deepest setting no matter how "important" it feels.