Planning and reasoning capabilities are what turn a language model into an agent. A chatbot answers a prompt and stops. An agent takes a goal, works out a sequence of steps, acts on the world through tools, watches what happens, and adjusts its plan until the job is done or it needs a human. Google Cloud defines AI agents as software systems that use AI to pursue goals and complete tasks on behalf of users, showing reasoning, planning, and memory, with a level of autonomy to make decisions, learn, and adapt.
What planning and reasoning capabilities mean inside an AI agent
Planning and reasoning are related but different jobs. Planning looks forward: it turns a goal into an ordered sequence of steps, with dependencies, constraints, and a definition of success. Reasoning works out what to do next from the evidence at hand: the goal, the tools available, and everything observed so far. Planning means identifying the necessary steps, evaluating potential actions, and choosing the best course, often anticipating future states and obstacles. Reasoning is using logic and available information to draw conclusions and solve problems.
Google Cloud lists five central capabilities of an agent: reasoning and planning, synthesizing and transforming, generating and evaluating, taking actions, and memory and learning. Anthropic’s December 2024 guide adds the architectural frame: the basic building block is the augmented LLM, a model enhanced with retrieval, tools, and memory. Anthropic draws a line between workflows, where LLMs and tools follow predefined code paths, and agents, where LLMs dynamically direct their own processes and tool usage. Neither works alone: reasoning without a plan drifts, and a plan without reasoning cannot adapt.
Planning capabilities: from goals to checkable steps
Planning starts with goal parsing. A goal such as “book a trip” is not yet a plan: it needs dates, a budget, and a rule for when no option fits. The first capability is goal decomposition: breaking the goal into ordered subtasks with dependencies between them. The second is sequencing and constraint handling. A useful test: can each step be checked? “Find the best option” cannot; “retrieve the three cheapest options that meet the budget and dates, then compare them on price and travel time” can.
A plan can be represented as data, not prose. The example below is a complete plan object for a small task: goal, success criteria, and each step with its dependencies and its check. It is a data example, not a program.
{
"goal": "Book a two-night trip within a $600 budget",
"success_criteria": [
"Flights and hotel booked",
"Total cost at or below $600",
"Confirmation numbers stored"
],
"steps": [
{
"id": "search-flights",
"action": "Search flights for the given dates",
"depends_on": [],
"check": "At least three options returned"
},
{
"id": "search-hotels",
"action": "Search hotels near the destination",
"depends_on": [],
"check": "At least three options returned"
},
{
"id": "compare",
"action": "Compare flight and hotel combinations on total cost",
"depends_on": ["search-flights", "search-hotels"],
"check": "Cheapest valid combination identified"
},
{
"id": "approve-booking",
"action": "Ask a human to approve the booking before any payment is taken",
"depends_on": ["compare"],
"check": "Human approval recorded"
},
{
"id": "book",
"action": "Book the cheapest valid combination",
"depends_on": ["approve-booking"],
"check": "Confirmation numbers received"
},
{
"id": "store-confirmations",
"action": "Store the confirmation numbers with the booking record",
"depends_on": ["book"],
"check": "Confirmation numbers stored and retrievable"
}
],
"escalation_rule": "If no combination fits the budget, stop and report the cheapest option found"
}The third capability is knowing which kind of plan fits. Some plans are fixed in advance, like a checklist written in code: Anthropic calls these fixed workflows, where LLMs and tools follow predefined code paths. Prompt chaining is a different pattern — it decomposes a task into a sequence of steps, each handled in turn, so one step’s output feeds the next. Other plans are generated on the fly, with the model deciding the next subtask after seeing the previous result. The fourth capability is contingency planning: what the agent does when a step cannot run as written. A plan with an escalation rule, like the one above, has somewhere to go when the world does not cooperate. A plan without one risks repeating the same failed attempt over and over, because nothing in the plan says when to stop, report, or try something else.
Reasoning capabilities: how agents think through a step
The most basic reasoning capability is chain-of-thought prompting: asking the model to write out its reasoning step by step before giving the final answer. Wei and colleagues at Google introduced it in 2022. With eight worked examples, PaLM 540B went from 17.9% to 56.9% accuracy on GSM8K, a maths benchmark, and the gains appeared only in models of about 100 billion parameters or more. Kojima and colleagues showed the same effect needs no examples: appending “Let’s think step by step” raised text-davinci-002 from 17.7% to 78.7% on MultiArith and from 10.4% to 40.7% on GSM8K. Self-consistency, introduced by Wang and colleagues in 2022, samples several independent chains and keeps the answer most agree on, lifting PaLM 540B on GSM8K from 56.9% to 74.4% at several times the cost.
The next capability is tool-mediated reasoning: using observations to check reasoning against the world. ReAct, introduced by Yao and colleagues in 2022, interleaves the two: the model generates a reasoning trace, acts through a tool, observes the result, and reasons again. On ALFWorld, a text-based household task environment, ReAct with PaLM-540B reached a 71% success rate, against 45% for acting without reasoning and 37% for imitation learning baselines. On WebShop it reached 40% against 30.1% for act-only prompting. On question answering and fact verification, interacting with a Wikipedia API let ReAct overcome the hallucination and error propagation that pure chain-of-thought suffers from.
The last capability is reflection: catching errors before they compound. Reflexion, introduced by Shinn and colleagues in 2023, has the agent write a short natural-language reflection after a failed attempt, store it in episodic memory, and read it on the next attempt, without updating any model weights. It reports 91.0% pass@1 on the HumanEval coding benchmark with GPT-4, against 80.1% for a single GPT-4 sample, and 130 of 134 ALFWorld tasks solved over 12 trials, against about 75% for ReAct alone. But reflection’s gains depend on grounded feedback. The paper’s own ablation shows reflection without test generation scored worse than doing nothing on the hardest HumanEval Rust problems, and on MBPP Python it scored 77.1% against an 80.1% baseline, because self-written tests had a 16.3% false-positive rate. It also did not help on WebShop. Huang and colleagues found the same pattern in a 2024 study of intrinsic self-correction: with no external feedback, performance often fails to improve and sometimes gets worse.
Advanced planning techniques: search, trees and hierarchies
Chain-of-thought follows one line of reasoning. Tree-of-thoughts, introduced by Yao and colleagues in 2023, replaces the line with a search tree: the model generates several candidate next steps, evaluates the partial solutions, keeps the promising branches, and backtracks from dead ends. On the Game of 24 puzzle, GPT-4 with chain-of-thought solved about 4% of the games; the same model guided by tree-of-thoughts solved 74%. The price is steep: the original paper reports 5 to 100 times more generated tokens than a single chain-of-thought call. That cost makes explicit tree-of-thoughts expensive to run at scale. Whether its search ideas are embedded inside current reasoning models, or used only as explicit prompting, is an open question in the evidence used here.
Two more techniques complete the picture. Hierarchical planning breaks a large goal into plans of plans, each with its own success criteria: the natural shape for long-horizon work. A world model simulates outcomes before acting, so the agent can reject a bad plan without trying it. Both are worth knowing about; which techniques builders actually use in production is an open question in the evidence used here, so this article makes no claim about it.
How planning and reasoning work together in the agent loop
In a running agent they alternate inside a loop: the plan says what to do next, reasoning decides the next step from the latest observation, and the observation updates the plan. The core execution pattern is the reason-act-observe loop, formalised as ReAct. The fragment below shows the shape of that loop. It is an illustration of the structure, not a working agent: a real implementation would call a model API, parse tool calls, and handle errors at each step.
# Simplified illustration of the reason-act-observe loop structure.
# Not a working agent: no model call, no real tools.
def run_agent_loop(goal, tools, max_steps=10):
history = [f"Goal: {goal}"]
for step in range(max_steps):
thought = f"Step {step + 1}: what is still missing for this goal?"
history.append(thought)
action = choose_next_action(history, tools)
if action is None:
return "Done: " + "; ".join(history)
observation = tools[action["tool"]](**action["arguments"])
history.append(f"Observed: {observation}")
return "Stopped: step cap reached, human review needed"Two parts of the loop deserve attention. The first is replanning: when a tool errors or an observation contradicts an assumption, the agent detects the failure and revises only the affected part of the plan. The second is the stopping rule. A loop stops when the success criteria are met, when a step cap is reached, or when the situation calls for a human. Without one, an agent can keep retrying a failing step indefinitely. The companion article on how AI agents use LLMs to reason and plan covers this loop in depth.
How to measure planning and reasoning capabilities
Capabilities are only as real as their measurement, and agent benchmarks are where the numbers live. Each benchmark tests one slice of an agent’s job, and none covers the whole thing. GAIA, from Meta AI and Hugging Face, asks 466 questions that are conceptually simple for humans but require browsing, tool use, file handling, and multi-step verification. In the original 2023 paper, humans scored 92% and GPT-4 with plugins scored 15%. By October 2026, the top submitted systems scored about 94%, above the human baseline, which means GAIA no longer separates frontier agents.
SWE-bench tests coding agents on real GitHub issues: a task counts only if the patch fixes the issue without breaking existing tests. On SWE-bench Verified, a 500-task human-validated subset, the best scores reached about 76.8% to 79.2% in early 2026. OpenAI stopped reporting it in February 2026 because of contamination and flawed tests; its successor, SWE-bench Pro, had a best score of 61.5% in October 2026. Tau-bench tests tool use in simulated customer conversations. Its authors reported in 2024 that state-of-the-art agents succeeded on fewer than half of the tasks, with pass^8 — success on all eight repeated runs — below 25% in the retail domain. OSWorld tests computer use; the best agent completed 72.1% of tasks in 2026 against 72.4% for people, while the newer OSWorld 2.0 had a best score of 20.6% in October 2026.
Three rules keep these numbers honest. First, a score measures one model, inside one agent setup, on one version of a test, on one date. Second, scores are not comparable across benchmarks: a number from one test says nothing about performance on another. Third, a saturated benchmark is a spent signal: GAIA’s top systems now score about 94%, above the 92% human baseline, so GAIA no longer separates frontier agents, and OpenAI stopped reporting SWE-bench Verified in February 2026 because of contamination and flawed tests, its successor SWE-bench Pro having a best score of 61.5% in October 2026. For your own work, Anthropic’s evaluation guidance suggests starting small: roughly 20 to 50 simple tasks taken from real failures is a good start.
Where planning and reasoning break down
Agents can break in ways that become more consequential across a trajectory than in a single model call. The first is hallucinated plans and invented tool arguments: the model invents parameters that feel correct, such as guessing a field name from training data instead of checking the tool’s schema. The second is looping: without a termination condition, an agent retries a failing step again and again. The third is compounding error: a bad step can taint the steps that depend on its output, so an early mistake can propagate through the rest of a long trajectory. The fourth is goal drift: as context grows, the original goal gets buried under pages of intermediate reasoning, and the agent starts optimising for the most recent step rather than the original objective.
Choosing the right capability level for your task
Not every task needs an agent. Anthropic’s advice is to find the simplest solution possible and only increase complexity when needed. A fixed workflow beats an agent when the steps are known in advance and the task needs consistency and predictability. Full planning, with decomposition, search, and reflection, earns its cost when the task is long-horizon, the number of steps cannot be known in advance, and the plan must adapt to what the world returns.
Use this checklist on any agent plan, including one you built yourself. Is the goal stated with success criteria and constraints, not just a vague request? Are the steps ordered, with dependencies explicit and each step verifiable? Are failure paths handled: what happens when a tool errors, a search returns nothing, or an observation contradicts the plan? Is there a stopping rule: a step cap, a success check, and a human gate for irreversible actions? Before trusting an agent with an irreversible action, test it on tasks drawn from your own real failures, with a ground-truth check on the outcome. Judge the loop, not the fluency.
