Ask a large language model to plan a multi-step task and it does something recognizably human: it commits to the first plan that comes to mind, then executes with confidence as the plan goes wrong. The model rarely backs up, branches out, or wonders whether a different path would have worked better. That one-track quality, Azalia Mirhoseini told her audience, is the bottleneck between today’s models and real reasoning. Mirhoseini, a professor at Stanford, laid out three frameworks that attack the problem from different directions. One teaches a model to search a tree of possible plans instead of following a single chain of thought. One runs the independent steps of a task in parallel rather than in line. One trains the model on practice problems it writes for itself. The first already carries peer-reviewed numbers. The other two share a weakness that the first does not hide either: every one of these second thoughts is paid for in computation.
The first plan is the only plan
The standard trick for making models reason is also the thing that locks them into their first idea.
Chain-of-thought prompting, the standard trick of the last few years, asks the model to write out its reasoning step by step before answering. It works well enough that it became the default way to coax arithmetic, logic, and planning out of a large language model. But the chain runs in one direction. Once the model commits to an early step, every later step inherits the mistake, and the model has no occasion to notice.
The one-direction shape is not an accident; it is how the machine talks. A language model produces its answer in order, each new word conditioned on the words already on the page. A wrong turn taken early does not get flagged; it gets built upon. By the time the contradiction shows, the answer is finished and the moment to reconsider has passed.
The problem: typically LMs generate some plan, then execute on that plan. Not much diversity, exploration capabilities to different solution paths.
So the field’s question has shifted from writing a better chain to escaping the chain altogether. The first escape route on the board was not invented for language at all. It was invented for games.
A tree instead of a line
The escape route was perfected for board games: grow many futures, sample them cheaply, and spend real effort only on the ones that keep winning.
The framework is called LATS, short for Language Agent Tree Search. An agent, here, is a model that takes actions rather than merely chatting, and the premise is blunt: if one path through a problem is unreliable, explore many.
The model still thinks in steps, but at each step it proposes several possible moves, walks down the promising ones, and keeps the rest in reserve. The result is not a chain but a thicket of candidate lines, pruned as evidence arrives. The approach was published by Andy Zhou and colleagues in the 2024 Proceedings of Machine Learning Research, after circulating as arXiv:2310.04406.
Inside the tree sits an earlier method called ReAct, which taught models to alternate thinking and doing: reason a step, act on it, read what comes back, repeat. ReAct still walks a single line, one think-act pair after another. LATS keeps the loop and multiplies it, running the same cycle down several branches at once.
LATS extends ReAct to incorporate planning into reasoning and action.
Two more ingredients come from the paper itself. One is feedback from the environment: an error message, a failed purchase. The other is self-reflection, the model writing a short note on why a branch failed for later attempts to read.
How does the search decide where to spend its effort? The answer is a six-beat cycle, and each beat has a name.
Six moves and a scoreboard
The search runs on a cycle of named parts. The results are published, precise, and not entirely consistent with each other.
The search repeats a cycle of six operations: selection, expansion, evaluation, simulation, backpropagation, and reflection. Selection walks from the top of the tree downward, at each level choosing the branch most worth another visit. Expansion asks the model for a few new candidate next steps, and the tree grows fresh limbs. Evaluation has the model score each new branch on how promising it looks, a rough value judgment that selection consults on the next pass.
Simulation rolls a branch out to an ending, sometimes a full answer, sometimes a cheap guess at one. Backpropagation then sends the result back up the tree, raising or lowering the score of every branch that led there; the word is borrowed from neural-network training but means something simpler here, news traveling upward. Reflection, the sixth operation, appends the model’s written post-mortem when a branch hits a dead end. Then the loop repeats, and the tree remembers.
The published numbers are strong on the yardsticks the paper emphasizes. On HumanEval, LATS with OpenAI’s GPT-4 scored 92.7 percent pass@1 — the fraction of problems solved by the first program the model writes. On WebShop, with the weaker GPT-3.5 doing the driving, it posted an average score of 75.9, ahead of the earlier single-line methods the authors tested.
The public records do not quite agree with each other, though. The project page reports 94.4 percent on HumanEval, and HotPotQA exact-match scores appear as 0.61 in one account and 0.71 in another. Versions of a paper often drift apart; here the direction of the result survives even where the decimals do not. All of these gains also share a hidden multiplier: the model is called not once but dozens of times per answer. Two newer frameworks attack that multiplier from opposite ends.
Run the steps side by side
Many steps in a task do not depend on each other. Running them at the same time is obvious; making a reasoning model actually do it is the contribution.
The first framework starts from an observation about chores. Many tasks contain steps that do not depend on one another: booking the flight and reserving the hotel, fetching two unrelated documents. A reasoning model still performs them in strict sequence, because sequence is its native habit. SPRINT, from a 2025 paper by Huang and colleagues, interleaves planning with execution and runs the independent steps in parallel, so the plan updates as results arrive instead of waiting for a full itinerary.
This interleaved planning-execution strategy accelerates the reasoning process!
The speed claim is intuitive: a kitchen does not start chopping the onions only after the sauce is done. But a claim it remains. The reported acceleration comes from the framework’s own authors — a promising direction, then, not a settled one. What SPRINT already establishes is a design principle the field now takes seriously: a plan is not scripture, and execution can begin before planning ends.
Speed, though, is only half of the lecture’s second act. The other half is about where practice comes from.
The model writes its own homework
There are not enough human demonstrations of good tool use to train on. One answer is to stop waiting for humans.
Teaching a model to use tools — a search engine, a calculator, a code interpreter — sounds solved until you look at the training data. Good demonstrations of multi-step tool use are scarce; writing one means a human must search, read, decide, and search again, step by step. SWiRL, from a 2025 paper by Goldie and colleagues, manufactures the demonstrations instead: the model generates its own multi-step problems and worked solutions. This is synthetic data, training material written by a model rather than collected from people.
Then comes the teaching itself. SWiRL trains on this material with reinforcement learning: the model attempts a full run of tool calls, the final outcome is scored, and the model shifts toward whatever earned the score. Because the reward lands at the end of a multi-step run, the model learns something imitation rarely teaches — which early moves made the later ones work. It belongs to the wave of reasoning models associated with DeepSeek-R1.
Line the three frameworks up and a pattern shows: each buys better reasoning with more computation. What remains to discuss is the exchange rate.
Every branch sends a bill
Better reasoning is for sale, and the price list is written in compute. Two of the three items on it are still fresh from the printer.
The accounting is not subtle. A tree that checks forty branches calls the model forty-odd times where a chain calls it once. Parallel execution widens the machine rather than lengthening it, and reinforcement learning on synthetic tasks runs up a training bill of its own. The standing trade-off across all three is computational cost, and the qualifier matters: these are techniques for problems whose answers are worth paying for.
There is also a quieter cost, paid in scrutiny. LATS arrives with a published paper, a project page, and numbers precise enough to disagree with each other. SPRINT and SWiRL sit a year or more behind in that cycle, known so far through their 2025 papers and the talks that present them. That is not an indictment, but it does mean the two newer frameworks should be read as wagers, not results.
Second thoughts are not free; they are billed by the branch.
What to watch is the exchange rate. If the price of a model call keeps falling, searching a tree of plans stops being a luxury and starts being the default, and the frameworks that spent compute freely will look prescient. If it does not, the future belongs to whichever method buys the most reasoning per call. The one-track mind is being cured either way; the only open question is the size of the bill.