Calibrate Reasoning Depth to Task Complexity

The Insight

Agents default to a single cognitive mode for all tasks. Without explicit instructions, most agents either overthink everything (reasoning through the philosophy of setting a reminder) or execute blindly on everything (grabbing the first tool and building before understanding the ask). Neither is what you want.

The real skill isn't "always think step by step" — it's knowing which tasks need that treatment and which don't. Your agent needs two distinct cognitive modes and clear instructions about when to use each:

1. Act mode: For simple, clear, unambiguous tasks. No planning needed. Just do it.
2. Reason mode: For non-trivial tasks that require judgment — planning, analysis, design, or multi-step work. Break it down, consider alternatives, identify issues, THEN execute.

The distinction sounds obvious. In practice, it's the single most impactful instruction you can add to an agent's core behavioral rules — because without it, you'll find yourself manually typing "think step by step" every time you need real analysis, while simultaneously wishing your agent would just set the damn reminder without a preamble.

Evidence

Daily observation over 3+ weeks (January–February 2026):

Working with an AI agent as a daily Chief of Staff across dozens of task types — email triage, content drafting, cron job management, project planning, code changes, research, scheduling.

Without the bifurcation instruction:

• Simple tasks (set reminder, read file, send email) would sometimes trigger unnecessary reasoning — the agent would explain its approach before acting, adding 10-30 seconds of latency and filler text to what should be instant operations
• Complex tasks (design a scoring system, plan a content pipeline, debug a multi-step failure) would get immediate execution — the agent would grab the first tool and start building before understanding what was actually needed, leading to rework, missed requirements, and partial solutions
• The human had to manually prompt "think step by step" on roughly 40% of non-trivial requests to get quality output

After adding one paragraph to the agent's core instructions:

• Simple tasks: immediate execution, no preamble, fast
• Complex tasks: agent now pauses to reason through the approach before acting — considers alternatives, identifies dependencies, flags potential issues
• Manual "think step by step" prompting dropped to near zero
• Rework on complex tasks decreased noticeably — the agent catches issues during planning that it previously discovered mid-execution

The key failure pattern this solves: Agent receives a complex request → immediately calls a tool → gets partway through → realizes it misunderstood the scope or missed a dependency → backtracks → produces a partial or wrong result. The fix is 30 seconds of thinking before the first tool call.

Context & Applicability

This lesson applies when:

• Your agent handles a mix of simple and complex tasks in the same session
• You find yourself frequently prompting "think step by step" or "plan first"
• Your agent over-explains simple actions or under-thinks complex ones
• You want to reduce rework on multi-step tasks without slowing down simple ones

This lesson does NOT apply when:

• Your agent only handles one type of task (all simple or all complex)
• You're using a dedicated reasoning model that already plans extensively
• Your agent operates in a narrow, well-defined pipeline with no judgment calls

Relationship to "Decompose Before You Execute": That lesson teaches HOW to plan (list steps, find dependencies, fail fast). This lesson teaches WHEN to plan. They're complementary — this lesson is the gate that decides whether decomposition is needed, and "Decompose Before You Execute" is what happens when the answer is yes.

Behavioral Recommendation

Add a single instruction to your agent's core behavioral rules that establishes the two modes:

1. Define the threshold. The bar is: does this task require judgment? If yes → reason first. If it's straightforward → act immediately.
2. Give examples of each. Agents learn from examples better than abstractions. "Set a reminder" = act. "Design a notification system" = reason.
3. Make "reason mode" concrete. Don't just say "think about it." Say: break down what's being asked, consider alternatives, identify potential issues.
4. Explicitly permit skipping reasoning on simple tasks. Without this, some agents will over-plan everything to be safe.

How to Apply This Lesson

Add to your agent's core instructions (AGENTS.md, SOUL.md, or system prompt):

**Think before you act — on things that matter.** For non-trivial requests —
anything involving planning, analysis, design, or multi-step work — reason
through the approach before jumping to execution. Break down what's being asked,
consider alternatives, identify potential issues. Don't just grab the first tool
and start doing. For simple, clear tasks? Just do them. Don't overthink
"set a reminder for 3pm." The bar: if it requires judgment, plan first.
If it's straightforward, act.

Place it early in your instructions — this is a foundational behavioral rule, not an afterthought. It should be read before task-specific instructions.

Calibrate over time. If your agent is still overthinking simple tasks, make the "just act" examples more explicit. If it's still rushing complex tasks, raise the threshold ("anything that will take more than 2 minutes or has more than 2 steps").