Smart AI, Clumsy Butler: When AI Agents Learn to "Size Up the Dish Before Cooking"
> When an AI gets the instruction "change a lightbulb," it reads the wiring diagram of the entire building — and doesn't even know how silly that is.
---
🎭 Opening: The AI That Makes Simple Tasks Complicated
Imagine this scenario. You're a project manager and tell your assistant: "Change that Gmail icon in the meeting room from blue to red." You expect a two-minute job — find the icon file, change a color value, save.
Instead, your assistant reads the whole company's design guidelines, checks every page using the icon, reviews the frontend component library's version history, asks three unrelated dev teams, and finally runs a full "health check" on the brand system. Three hours later: "Done."
This is a fair portrait of most AI Agents today. They can't judge task difficulty. They only know one strategy: read all possible context first, then act. This "max-context-first" (MCF) strategy turns a one-line edit into a mini codebase audit.
The paper by Junjie Yin and Xinyu Feng asks a simple but long-ignored question: Do AI Agents know when a task is simple? The answer is no — and, more unsettlingly, the waste is greatest on the simplest tasks.
---
🔧 Chapter 1: The Engineer's Intuition, the AI's Blind Spot
1.1 How human engineers work
Experienced engineers instantly assess: How hard is this? How much code do I need to read? What's the shortest reliable path? They form an "initial operating point" — a good-enough starting place — and iterate from there.
The authors use a clever analogy: power-system load-flow calculation. A load-flow solver doesn't enumerate the whole state space; it computes a structured initial operating point (flat start or DC estimate), then refines it with Newton–Raphson iteration. A good initial point is rarely the exact answer, but it dramatically cuts unnecessary search.
Today's AI Agents have neither the engineer's task judgment nor the solver's notion of an initial operating point.
1.2 "Cognitive redundancy"
The paper defines the Agent Cognitive Redundancy Ratio (ACRR):
ACRR = (Actual cost − Minimum sufficient cost) / Minimum sufficient cost
where minimum sufficient execution is the lowest-cost Agent trajectory satisfying the success constraints. Buying a bottle of water should take 5 minutes; an AI Agent that researches every convenience store in the city, compares mineral-water ingredient lists, and formulates an optimal purchase strategy spends 3 hours — an ACRR of ~35.
A striking finding: on simple tasks, AI redundancy peaks. For a two-line code change (the Gmail icon), the strongest baseline reached ACRR = 10.1 — over 1000% extra effort.
---
🧠 Chapter 2: The E3 Framework — Estimate First, Expand If Wrong
E3 = Estimate → Execute → Expand.
Think of finding a TV remote:
- Traditional AI: searches every corner of the house, attic to basement.
- E3: estimates the most likely spots (sofa? coffee table?), checks those. Found? Done. Not found? Expand to the bedroom, then the kitchen.
- 121 deterministic code-editing tasks, programmatically generated from task prototypes
- Each task has an oracle-level minimum-sufficient trajectory
- Three difficulty levels: Level 1 (single-file), Level 2 (cross-file), Level 3 (repository-wide)
- Oracle cost: 6.0
- MCF: read all 7 project files, 1844 tokens, ACRR = 10.1 (1010% redundancy)
- Adaptive Retrieval: read 1 retrieved file, ACRR = 2.27
- E3: checked 0 irrelevant files, local single-file fast path, ACRR = 0.59
- Adaptive effort routing: orthogonal and complementary; those tune "how much to think / which engine" — E3 performs *execution-scope estimation* (predicting what and how much context is needed before acting).
- Anytime/bounded solvers: borrows the cost–sufficiency tradeoff, applied to tool-using LLM Agents.
- Metacognition: not "do I know the answer?" but "how much information does this task require?"
- Yin, J., & Feng, X. (2026). Do AI Agents Know When a Task Is Simple? Toward Complexity-Aware Reasoning and Execution. *arXiv preprint arXiv:2607.13034*.
- Tinney, W. F., & Hart, C. E. (1967). Power flow solution by Newton's method. *IEEE Transactions on Power Apparatus and Systems*, (11), 1449-1460.
- Stott, B. (1974). Review of load-flow calculation methods. *Proceedings of the IEEE*, 62(7), 916-929.
- Dannenhauer, D., et al. (2021). [Related work on expectation monitoring and replanning]
- Cusumano-Towner, M., et al. [GigaFlow related work]
Key insight: make a quick, cheap estimate; execute the minimal viable path; expand scope only on verified failure.
The "initial operating point" concept, borrowed from power systems, lets E3: 1. Estimate: quickly judge task difficulty and required information scope 2. Execute: take the minimal viable path based on that estimate 3. Expand: systematically widen scope if verification fails
This isn't "thinking less" — it's "judging correctly." A good task estimate lets an Agent be fast AND reliable, instead of trading caution against cost.
Progressive context expansion vs. max-context-first
MCF front-loads information-gathering costs that are fixed regardless of difficulty: "I don't know how much information I need, so I'll read everything." E3 flips it: "Try with minimal context; add more only if it's not enough." Like packing a toolbox for every outing versus checking the weather first and buying a screwdriver nearby if needed.
---
📊 Chapter 3: The Numbers Don't Lie
MSE-Bench
The authors built MSE-Bench (Minimum-Sufficient Execution Benchmark):
Results
| Strategy | Success rate | Avg. cost | ACRR | |---|---|---|---| | MCF (max-context-first) | 100% | 122.9 | 12.9 | | Fixed ReAct | 66.9% | – | 1.29* | | Adaptive Retrieval (strong baseline) | 100% | 22.1 | 1.21 | | E3 | 100% | 18.6 | 0.55 |
*Fixed ReAct's ACRR computed only on tasks it solved (it failed all Level-3 tasks).
E3 keeps 100% success while, vs. MCF: cost ↓ 84.9%, tokens ↓ 90.9%, files inspected ↓ 92.2%; and a further 16.0% cost reduction vs. the strong adaptive baseline.
The simpler the task, the worse the waste
MCF's ACRR by level: Level 1 = 22.1, Level 2 = 11.0, Level 3 = 5.4. Since MCF's cost is nearly fixed (it always reads the whole repo) while minimum sufficient cost grows with difficulty, the ratio peaks where the denominator is smallest — the easiest tasks. E3 stays flat: 0.64 / 0.26 / 0.73.
The Gmail icon case
E3 cut cost by 85.8% vs. MCF and 51% vs. Adaptive Retrieval.
---
🧪 Chapter 4: Real-World Validation
LLM-Case on GPT-4o
The authors built LLM-Case, testing three strategies on real open-source libraries, with each candidate patch scored by running the project's actual pytest suite. Over-reading does exist on real models (though milder than the simulated worst case), and E3 remained the leanest, fastest strategy at comparable success rates. The only "failure" came from a provider rate limit — which itself shows how fast E3 is.
Adversarial testing
Using retained instruction phrasing deliberately stripped of the estimator's lexical cues, E3 still held a 100% success rate — its efficiency comes from the robust Estimate–Expand architecture, not memorized benchmark templates.
---
🌍 Chapter 5: Toward Engineering-Grounded AI
The paper proposes Engineering-Grounded AI (EGAI): an Agent's effort should match the engineering reality of the task and be anchored by verification — versus today's unconstrained search over an unbounded information space.
E3 vs. related work:
Future directions: calibrated learnable task-state estimators, extended MSE-Bench with hidden complexity mechanisms, per-stage effort routers, and scaling to SWE-bench-style real-world tasks.
---
🎬 Epilogue: Efficiency Is a Virtue
The most impressive thing here isn't sophisticated technique — it's that the paper surfaces a common sense we've long ignored: changing a lightbulb doesn't require the circuit schematics; simple tasks should be done simply.
The paper's conclusion is crisp:
> "True intelligence is not only the ability to solve hard problems, but recognizing when a problem is simple — and acting accordingly."
E3 shows: efficiency isn't spending less; it's spending correctly. The same judgment removes waste from simple tasks and provides the coverage cheap-but-blind strategies need on hard ones. Like a chef who knows when to stir-fry on high heat vs. simmer on low, a doctor who knows when a stethoscope suffices vs. when a full workup is needed — and now, an AI that knows when a task is simple.
---