Agentic Reasoning: When the LLM Gets Off the Couch
Everything became an "agent" lately. A chatbot is an agent, a script with a for loop is an agent, a fancy prompt is an agent. The word wore out about as fast as "synergy" did back in the day. So I read (diagonally, no lecture-level commitment) a giant survey called Agentic Reasoning for Large Language Models, signed by people from Illinois, Meta, Amazon, Google DeepMind, UC San Diego, and Yale, all on the same paper. When that much heavy-hitter firepower gets together to write 70-something pages organizing one topic, you can reasonably suspect it's not just a fad.
The real difference: passive versus interactive
The paper sums this up in a table I loved, comparing "LLM reasoning" against "agentic reasoning". Let me retell it in a goofier version:
A regular LLM reasoning is like the office coffee machine: you press the button, it spits out its coffee, done. Doesn't matter how many times you press it again, it'll never remember you asked for no sugar last time, because it has no memory, doesn't observe the outcome of what it did, it's a one-shot deal, zero interaction with the world after answering.
Agentic reasoning is the new hire who learned your order by week two. They use a tool (grab the right mug), fetch information when needed (ask if you want a cappuccino today), carry context from one interaction to the next (remember yesterday's order), and adjust their behavior over time. The paper formalizes this nicely: instead of a one-way π(answer | question), the model becomes a loop that decides, acts, observes the result, and decides again, as many times as it takes. That's the difference between answering and doing.
Three floors, each more ambitious than the last
The survey organizes everything into three layers, and I found it easier to think of them as an intern's career progression:
Floor 1, foundational agentic reasoning: the intern on day one. Knows how to plan a task by breaking it into smaller pieces, knows how to use whatever tools the company provides (call an API, run some code), and knows how to look things up when they don't know something (search the web, check the docs). That's already enough to handle a task inside a stable environment, but they don't yet learn anything from one task to carry over to the next.
Floor 2, self-evolving agentic reasoning: the same intern, three months later. Now they reflect on their own mistakes ("last time I did it this way it went badly, let me try differently"), keep memory of what already worked, and keep adjusting how they work based on accumulated experience. The paper splits this into three flavors, and the real examples are great. Verbal evolution is literally the intern writing themselves a note ("don't forget X next time"), which is what the Reflexion framework does, plain text guiding the next attempt. Procedural evolution takes it further, building a whole new toolbox as they learn (Voyager does this playing Minecraft, creating reusable code functions for every new skill it picks up). And structural evolution is "what if the intern rewrote their own employment contract", where the system (AlphaEvolve, for instance) uses an LLM to modify its own source code, treating its own algorithm as a hypothesis to be tested and improved. That last one is scary in how ambitious it is.
Floor 3, collective agentic reasoning: this isn't an intern anymore, it's the whole team. Multiple agents split roles (one plans, one executes, one critiques the others' work), exchange messages, and share memory. Frameworks like AutoGen and CAMEL live on this floor, literally simulating a team of people talking to each other to solve a problem together.
Cramming versus actually learning
Another distinction from the paper I liked: in-context reasoning versus post-training reasoning. In-context is cramming the night before: the model doesn't change a single weight, it just uses inference time to think more (try different paths, revise its own answer, fetch extra information), all within the same conversation. Post-training is actually studying: the good behavior becomes a permanent part of the model via reinforcement (the paper cites the GRPO formula, a reinforcement learning technique that adjusts the model by comparing a group of answers against each other, rewarding the best ones in the group), so next time it's already born knowing it, no need to relearn every new conversation.
A meta breather
I noticed something reading this: "floor 1" that I described above, plan the task, use a tool, look things up, verify the result, is literally what's happening right now, while this post is being written. Yes, this text you're reading was born from an agent (in the pretty technical sense the paper uses) reading the PDF, decomposing the task of writing the post, and verifying the result before publishing. The irony did not go unnoticed.
Wrapping up
| What I already knew | What this survey settled |
|---|---|
| "AI agent" became a marketing word | There's a real technical definition behind it: interaction, memory, and adaptation, not just a fancier prompt |
| ReAct and similar frameworks exist | They're just floor 1 of a three-level hierarchy, and the top (multi-agents coordinating) is far more ambitious |
| RL fine-tunes language models | The "in-context vs. post-training" distinction is about WHERE the improvement lives: in the current conversation, or permanently in the model's weights |
Practical application
To feel the core idea in your hands (interaction beats a single answer, in the survey's own words: "scaling test-time interaction"), I built the simplest game there is: guessing a number between 1 and 100.
def single_guess(target, guess):
# "regular LLM reasoning": one shot, no feedback at all
return guess == target
def agentic_guess(target, n=100, attempts=7):
# "agentic reasoning": uses the feedback (higher/lower) on every attempt
low, high = 1, n
for _ in range(attempts):
guess = (low + high) // 2
if guess == target:
return True
elif guess < target:
low = guess + 1
else:
high = guess - 1
return False
The single-guess version gets it right 1 out of 100 times, no matter how many "attempts" you let it have, because it never uses the outcome of the previous attempt. The agentic version uses the hint (higher or lower) to cut the search space in half every round, exactly the same logic behind binary search. The closed-form formula for the success chance with k attempts is min(2^k - 1, 100) / 100: every extra attempt doubles how many numbers you can cover with certainty.
Drag the slider below and notice: with just 1 attempt, the chance is the same for both methods (1%, you only get one bullet either way). But starting from the second attempt the blue line (with feedback) takes off, while the orange one (no interaction) stays stubbornly flat on the floor, because it simply never uses the new information each extra attempt could bring. By 7 attempts, the agentic version already hits 100% certainty. It's the same math behind "20 questions", just here it's only 7 because the search space is much smaller.
7%
Simple as that: interaction trades "luck" for "guaranteed math", and that's exactly the survey's central argument, just applied to a bunch of things far more impressive than guessing a number.