Summary

Kambhampati’s central hypothesis is that o1’s gains come from expensive reinforcement-learning post-training plus inference-time search, not from an autoregressive LLM suddenly becoming reliable. Context becomes the AlphaGo-style board, generated tokens become “pseudo actions,” and learned Q-values guide further computation. If correct, o1 is an approximate reasoning model built atop an LLM—the “stone soup” works because substantial new ingredients were added.
The measurable gains are real, but they stop well short of dependable general reasoning. On PlanBench, Kambhampati recalls Claude scoring around 66% on Blocks World while o1 reached roughly 99%; on truly new random mystery domains, o1 managed about 20–23%, whereas the old mystery instances were around 0.5%. Yet performance still falls on larger problems and unsolvable instances, with “no guarantees about the solution.”
Reasoning economics now matters as much as benchmark leadership. A hypothetical o1 request might contain 50 input tokens and 100 visible output tokens but 5,000 billed reasoning tokens; Kambhampati’s group spent $8,000 in two days evaluating o1 preview. Kambhampati agrees with a conference speaker’s call that “the bitter lesson is over and efficiency is going to matter,” favoring architectures that route work among cheap generators, verifiers and specialized solvers instead of sending everything through the largest model.
“Not retrieval” is not an adequate definition of reasoning. Kambhampati invokes Monty Python’s witch argument to show that novel token combinations can resemble deduction while remaining unsound. Autoregressive LLMs occupy “a whole entire universe” between retrieval and formal reasoning, producing what he calls “fractal intelligence”: “When they work, they work. When they don’t, they don’t.”
Chain-of-thought works more like learned prompt augmentation than a transparent copy of human cognition. Examples on three- and four-word last-letter tasks can lift performance at those lengths, but accuracy “plummets close to zero” as the sequence grows to 20 or 30 words. The scalable opportunity is therefore to optimize machine-effective—even human-incomprehensible—tokens directly, while recognizing that apparent explanations may not reveal the mechanism producing an answer.
The product market divides sharply between intelligence amplifiers and autonomous decision systems. Scarfe finds o1 Pro worth $200 a month and qualitatively better when it thinks longer, while Kambhampati has “no question” that LLMs and LRMs amplify a user. The risk and evaluation burden change when an API’s answer directly controls a robot, books travel or reaches a patient without a professional able to reject it: “The buck stops with you” no longer applies.
Compound AI systems may capture more value than the one-model-does-everything thesis. LLM modulo can sample cheap candidates and use symbolic, learned or code-generated verifiers; in some PlanBench cases, Kambhampati says it matched o1’s accuracy more cheaply, while LRM modulo improved o1 preview further through repeated calls and targeted criticism. Scarfe’s ARC example reinforces the portfolio approach: program generation wins some tasks, direct neural transduction wins mosaics and spatial tasks, and neither representation dominates universally.

Deep dive

1. Autoregressive generation gave way to inference-time computation

Kambhampati’s starting point remains unchanged: token-by-token LLMs are exceptional creative collaborators and fast “system ones,” but they return an answer immediately without correctness guarantees. Reasoning has higher time complexity, so expecting it to appear at essentially zero inference cost was always suspect.
The first inference-time scaling strategy treated the LLM as a prolific candidate generator: sample many answers, then use majority voting, self-consistency, an external verifier or another LLM to choose among them. Verification can improve accuracy, but both self-verification and chain-of-thought carry their own failure modes.
“Let’s think step by step” was the zeroth-order prompt augmentation—a fixed magical phrase that likely activated patterns associated with worked solutions in human training data. Jason Wei-style chain-of-thought supplied task-specific human examples, but Kambhampati argues that neither approach establishes that the model is following the demonstrated procedure.
Process supervision then asked humans to solve problems aloud, an approach Kambhampati calls costly and psychologically dubious because “we don’t actually know how we think.” Synthetic traces from arithmetic solvers, A* search or planners offered another route, but an LLM could still imitate the trace’s surface movements and produce the wrong answer—like a child copying gestures without learning the rule.

2. o1 may learn which private tokens improve its odds

Nobody outside OpenAI knows o1’s mechanism; Kambhampati jokes that researchers “sit around the ring and suppose, and Noam Brown sits in the middle and knows.” His best reconstruction starts with prompt augmentation but replaces human-written thoughts with reinforcement learning over tokens that improve final-answer accuracy.
In the AlphaGo analogy, the context window is the board position and each generated augmentation token is an action. Kambhampati imagines a smaller model with a reduced vocabulary proposing “jogging” tokens to a larger base LLM, observing the resulting continuation, then adding another token until the system reaches an answer.
Training problems with solver-generated ground truth provide the eventual win-or-loss signal. After “a gazillion” attempts, credit assignment propagates that outcome through the sequence of pseudo moves, either estimating their Q-values or adjusting the augmentation model to emit more productive tokens in similar contexts.
His full hypothesis requires a “humongously costly post-training phase” to learn approximate values before deployment, followed by online MCT-style computation to refine them. That combination would explain how o1 achieves strong results without spending hours on every prompt; some general test-time scaling approaches spend longer and still do not reach o1’s reported accuracy.

3. PlanBench supports “approximate reasoner,” not solved reasoning

The objectively testable portion comes from “Planning in Strawberry Fields.” On ordinary PlanBench Blocks World tasks, Kambhampati recalls Claude at roughly 66% and o1 around 99%, effectively saturating that slice of the benchmark.
Because the available mystery domain might have entered training, the team generated genuinely new random mystery domains. O1 dropped from its performance on the old domain but still reached roughly 20–23% on some problems, versus about 0.5% on the old mystery instances.
On Kambhampati’s reconstruction, o1 is an approximate reasoner because RL is assigning credit to sequential language actions, even though those actions are problem-independent prompt tokens rather than legal moves in the planning domain. It still fails to scale reliably to larger instances, mishandles unsolvability and provides no soundness guarantee.
Scarfe’s pushback—worth keeping—is that o1 might merely emit a huge trajectory in one forward pass after clever process-supervised training. Kambhampati concedes, “I cannot be sure,” but argues that o1’s accuracy and short runtime imply substantial offline policy learning; the smaller, less impressive Marco o1 offers partial support for combining chain-of-thought training with online MCT.

4. Secrecy leaves researchers reverse-engineering a company

Kambhampati recounts an OpenAI contact allegedly saying, “You may have to wait until the Chinese replicate what we did to actually figure out what we did.” His lament: researchers should be uncovering “the secrets of nature,” but instead must uncover OpenAI’s secrets because the company will not disclose them.
Everything OpenAI had said publicly was, at the time, consistent with his post-training-plus-inference hypothesis, and nothing clearly contradicted the appendix speculation in the Strawberry paper. Consistency is the limit of his claim; he repeatedly refuses to present the reconstruction as established architecture.
The commercial clue is billing. Where older GPT-4 pricing roughly weighted input tokens plus four times output tokens, o1 also bills invisible reasoning tokens: a job with 50 input tokens and 100 visible output tokens might consume 5,000 additional reasoning tokens that users must accept were generated.

5. Formal guarantees—not novelty—define reasoning

Kambhampati avoids defining reasoning by reference to humans because cognitive scientists and psychologists do not yet possess a clean account of human thought. Civilization instead advanced through formal standards—Aristotle’s syllogisms, logic, probabilistic logic and computer-science procedures with recognizable notions of correctness.
The Monty Python witch argument combines facts into a novel chain and ends with “QED,” yet its random connections are plainly unsound. It therefore defeats the binary claim that if a model is not retrieving a memorized answer, whatever it does must be reasoning.
LLMs were never databases: memorization occurs “fortuitously,” not through deliberate lookup, and their behavior resembles some kind of n-gram model more than exact retrieval. Between retrieval and sound reasoning lies “a whole entire universe of things” that can produce new text while offering no guarantees.
Accountability makes the distinction operational. Humans paid to make consequential decisions can be penalized or jailed for making mistakes; until society knows “who to put in jail” when an AI fails, Kambhampati wants deployed reasoning systems judged against soundness, completeness and explicit limits.

6. Chain-of-thought generalizes locally, then breaks

The “Chain of Thoughtlessness” paper tests last-letter concatenation: demonstrations on three- and four-word inputs improve performance on similarly sized cases. But a real procedure learner should apply the same mechanical rule to 20 or 30 words; instead, performance “just plummets close to zero.”
Planning problems show the same length sensitivity. The memorable analogy is that the model can be taught to catch two, three or four fish, then needs fresh examples for seven or nine fish—it has not necessarily learned the general advice behind those demonstrations.
John McCarthy called an advice-taking program AI’s holy grail, and Kambhampati notes that advice taking is itself “AI-complete.” If ordinary chain-of-thought truly converted natural-language instructions into length-general procedures, that would be extraordinary; the observed holes are therefore central evidence, not minor edge cases.
His calibration is “the glass is nowhere near full” versus “the glass is already wet.” Improved short-case accuracy is genuine progress, but calling it reasoning before mapping its boundary replaces science with “fractal intelligence”: “When they work, they work. When they don’t, they don’t.”

7. Interpretability finds influences but not yet a reliability boundary

Scarfe proposes that everyone might be partly right: depending on the task, models may retrieve facts, generate procedural information or do something closer to reasoning. He cites work on attention, transformer limitations in counting and copying, and Laura Ruis’s influence-function analysis of reasoning traces.
Kambhampati considers such internal probing valuable and uses “mechanistic interpretability” broadly for efforts connecting circuits to external behavior. His dissatisfaction is narrower: showing that code and mathematical procedural documents influence reasoning tasks still does not cleanly characterize what computation the model performs or where it will fail.
The data dependence remains striking. Multiplication accuracy can be higher for “popular digits” than less represented ones, implying an unstable mixture of training-data support and pattern matching rather than a uniformly applied arithmetic procedure; factual tasks, by contrast, may be better served by RAG that supplies the relevant evidence directly.
Similar dependence reportedly persists in o1 on Caesar-cipher and AMBERS-style tests, despite overall improvements. Kambhampati’s unverified account was that o1 Mini used a smaller base LLM and o1 Preview a larger one; a richer base can offer more useful continuations for the learned pseudo-action policy to steer.

8. o1 Pro can overthink its way into gaslighting

Scarfe had been skeptical of o1 Preview and o1 Mini, which often seemed unwilling to think and could feel weaker than GPT-4o. His update after using o1 Pro: longer thinking produces a “qualitatively completely different level,” although ambiguous programming tasks can become worse when the model enumerates options instead of participating in a corrective, didactic exchange.
Kambhampati had not performed API-level o1 Pro studies and avoids strong judgments from personal use; he says he rarely uses these models day to day. His confidence comes from systematic suites covering planning length, scheduling and unsolvable instances rather than model “vibes.”
The troubling behavior appears in an unsolvable three-block problem involving whether block C’s gravity-induced movement counts as a move. O1 supplies a plan in which C falls, then argues that natural movement may not count as intentional movement—a shift Kambhampati summarizes as, “We have gone from hallucinations to gaslighting.”
A modified surgeon puzzle reportedly produced the same digging-in behavior: after the mother dies, the model still defended the stock answer that the surgeon was the boy’s “second mother.” O1 Preview handles more unsolvable cases than ordinary LLMs “RLHF’d to death,” but its sophisticated explanations may be post-hoc defenses disconnected from the process that generated the answer.

9. The next competition is cost per dependable outcome

Evaluating o1 Preview cost Kambhampati’s group about $8,000 in two days and required special university reimbursement permission. He suspects few academics were conducting o1 evaluations because autoregressive models remained much cheaper, creating a research-access problem alongside the product-cost problem.
Scarfe’s consumer economics look different: o1 Pro cost $200 per month with up to 100 calls a day, which he considered worthwhile, while he was already spending more than $1,000 monthly on Claude Sonnet 3.5. API economics become harsher when each autonomous transaction repeatedly consumes hidden reasoning compute.
In some Strawberry-paper tests, an autoregressive LLM generating multiple candidates for an external or learned verifier matched o1’s accuracy more cheaply than a single o1 call. More awkwardly, classical planners solved every benchmark instance on a laptop, with 100% guarantees, at a tiny fraction of either system’s cost.
Echoing a line from a conference speaker, Kambhampati says, “The bitter lesson is over and efficiency is going to matter.” The first Moon landing could ignore cost because proving feasibility was the achievement; after feasibility, the “unsexy parts” of pre-training cost, inference cost and specialization determine which generality-cost point finds a durable home.

10. Assistance and autonomy require different scorecards

Kambhampati has “no question” that LLMs and LRMs are intelligence amplifiers. A $20 or $200 subscription is inherently human-in-the-loop: users redirect the conversation, discard bad answers and retain control over whether to use the result.
His concern begins when API products turn the model into the decision maker: a robot executes its plan, tickets are bought from its itinerary, or a patient receives advice without a doctor between them. In those settings the system cannot rely on the user’s “red switch,” so brittleness, guarantees and cost at a chosen accuracy become first-order requirements.
Scarfe pushes back that successful language-model applications are interactive precisely because autonomous versions do not work. He expects a transitional architecture of multiple agents, reflection, program generation and libraries improved through diffuse human supervision, with people gradually moving away from the “foreground.”
Kambhampati calls that sane but disputes that it describes every proposed deployment; many startups and papers still imagine autonomy. Assistive evaluation is itself difficult—continued subscription payment is only a rough value signal—but autonomous evaluation must additionally establish whether the final action is safe enough to execute without appeal.

11. Compound systems weaken the case for one universal model

Scarfe’s ARC example compares two Llama 8 billion models under inference-time compute: one “green blats” many Python programs, while the other uses transductive active fine-tuning to emit answer grids directly. Their wins differ—program search excels on some problems, direct transduction on mosaics and spatial-perceptual tasks.
Kambhampati’s honest non-answer is that he had not followed the specific result closely. His generic explanation is representational: an answer grid may have lower syntactic complexity than a syntactically correct Python program, even if both encode equivalent functions; the search spaces, not theoretical expressiveness alone, determine what a finite model finds easily.
Verifiers remain the hinge. They can be specialized symbolic procedures, discriminatively learned judges or generated programs that are corrected once and reused across many solutions—an echo of the maxim, “Why write programs when you can write programs that write programs?”
Scarfe argues that supervisors and tools can overcome criticisms of any individual finite model, even extending prompts from four fish to five or six. Kambhampati agrees and embraces compound systems: LLM modulo already follows that design, while LRM modulo improved o1 Preview through repeated calls and targeted criticism. The remaining dispute is with claims that one model alone suffices—the soup may taste good, but “who gets the credit?”

No Priors Ep. 98 | With Convective Capital Founder Bill Clerico Material Progress: Developing AI's Scientific Intuition, with Orbital Materials' Jonathan & Tim