The biggest mistake people make with AI agents is assuming the model is the whole system. It isn’t. The harness around it, context management, tools, memory, a real workspace, decides how much of that intelligence you actually get. Every section here has something to poke.
Intelligence you can actually use
A model in isolation does one thing. It reads what’s in front of it and produces the next tokens. Everything else, what it sees, what it can touch, what it remembers, what it can check, is a decision someone made in the surrounding code.
Which means the strongest model in a badly built harness can lose to a mid-tier model in a good one. That isn’t a hypothetical. Play with the two dials:
The relationship is a product, not a sum. A stronger model cannot buy back a harness that starves it of context, tools and feedback. Most teams spend months on the amber dial and a weekend on the green one, then conclude the model isn't good enough.
click the two presets and compare the black bars.
Context stops being a budget and becomes storage
First idea worth your attention: the Recursive Language Model. Instead of treating context as one giant prompt, the agent manages it programmatically: break the problem into smaller tasks, call sub-agents, save results, retrieve them later, combine and keep going.
Concrete version. You have 300 failing tests and want the agent to work out which failures share a root cause. Run it both ways:
the context window
recall sags right here, in the middle of a long context
space left for actual reasoning: …
parent agent's context: pointers, not payloads
parent window used: 0%
Left strategy: attention spreads thin, recall in the middle degrades, and the window is spent before any reasoning happens. Right strategy: each batch goes to a sub-agent with a clean context and one job; the parent holds pointers and reads a trace back only when it needs it.
run both. Watch what the parent is holding at the end of each.
The context window stops being a budget you spend down and becomes storage you address.
That’s a genuinely different shape of problem. And it means “the model has a 200k context window” tells you much less about what the agent can handle than people think it does.
The REPL is the workspace
Second idea: give the agent a read-eval-print loop. It can run code, create variables, save results, call functions and keep state. This is the difference between an agent that can only remember and an agent that can look things up and check. Ask for a weighted average over 50,000 rows both ways:
| value | weight |
|---|---|
| 61.2 | 0.4 |
| 18.9 | 2.1 |
| 44.7 | 1.0 |
| … 49,997 more rows | |
The inspection step is the part people undervalue. An agent with a REPL can be wrong and then find out it was wrong, in the same turn, without a human in the loop. An agent without one is wrong and then keeps building on being wrong.
run the REPL side and watch it catch its own first mistake.
State matters too. Variables persist. The agent loads a dataframe once and refers to it fifteen steps later, without re-reading the file into context or re-deriving anything it already computed. The expensive parts of the work stop getting repeated.
The shape of the loop changed
So instead of prompt, think, answer, you get think, code, delegate, save, inspect, iterate, answer. Step through it and notice the colours: every verb is either the model or something the harness had to provide.
Amber verbs are model capability. Green verbs are engineering you have to build or choose. Count them.
Delegate needs sub-agent orchestration. Save needs a filesystem or a store. Inspect needs execution and a way to read output back. Iterate needs all of it, plus loop control that knows when to stop. None of that is model capability.
The model might not be the bottleneck anymore. The harness might be.
So before concluding the model isn’t good enough, audit the code around it. What can it see? What can it touch? What does it remember? What can it check? Those four questions are the harness, and right now they are where most of the unused intelligence is sitting.
The demos on this page are simulations with hand-picked numbers: no models run in your browser, and the dials in the first section illustrate a relationship rather than measure one. The failure modes they act out (mid-context recall loss, confident wrong arithmetic, unchecked loops) are real and reproducible with any current model.