TOPIC
Reasoning Architectures
A subject the collection covers, read through 33 synthesis notes.
View as
When should an agent stop acting and admit failure?
Agents can refuse to answer, but the critical challenge is timing: knowing at which step to abstain when a task becomes infeasible. This matters because premature or delayed stopping directly affects system reliability.
RL agents trap themselves in information self-locking cycles Reasoning model collapses stem from execution limits not reasoning limits One completion bias mechanism produces three distinct agent failure modes Reasoning models fail systematically across exploration, mode selection, and social understanding. LLM knowledge failures follow structurally distinct patterns beyond simple wrongness
No Inquiring Lines yet
Does planning direction affect how hard problems become?
Planning research typically goes forward only. But some problems get easier when you work backward from the goal. What makes direction matter, and can language models exploit this?
How should we balance parallel versus sequential compute at test time? Can backward reasoning during training improve forward reasoning? Which sentences actually steer a reasoning trace? Can embedding future information in training data improve planning? Why does parallel reasoning outperform single chain thinking?
Parallel and sequential scaling represent a fundamental trade-off in test-time compute Backward reasoning training internalizes consistency checking for stronger forward reasoning Planning and backtracking sentences are disproportionately influential reasoning pivots Lookahead tokens in training data enable planning without architectural changes Parallel reasoning paths outperform extended single chains consistently
Do base models already contain hidden reasoning ability?
Explores whether reasoning capability emerges during pre-training as a latent feature rather than being created by post-training methods like reinforcement learning or fine-tuning.
Reinforcement learning emerges complex reasoning from simple objective rewards RL post-training optimizes reasoning deployment timing, not reasoning capability itself Prompt optimization retrieves existing knowledge but cannot inject new knowledge Training regime matters more than inference compute budget One training example activates mathematical reasoning and enables post-saturation generalization
What cognitive capabilities do agents need to internalize social feedback? Does AI knowledge precede actual expertise in hyperreal production? What makes conceptual inquiry the fastest high-scoring AI interaction pattern? How does instrumental reasoning reproduce pre-Enlightenment knowledge structures? Can better attention mechanisms close the gap between human and AI frame-activation? What would an AI trained for emancipatory reasoning look like? What other hidden biases might aggregate metrics fail to distinguish from reasoning? When does knowledge activation fail across different model architectures? Can steering a single latent feature replicate chain-of-thought performance? How do different LLM integration paradigms affect inheritance of pretraining biases? How do pretraining biases interact differently with prompts across model tiers? How does in-context learning trigger phase transitions in model behavior?See all 335 inquiring lines on this note →
Can modular cognitive tools unlock reasoning without training?
Can reasoning capabilities be elicited by structuring LLM calls as isolated cognitive operations—understanding, recalling, examining, and backtracking—rather than through reinforcement learning?
Base models contain latent reasoning capability unlocked by minimal training Structured critical questions force LLMs to check warrants and improve reasoning RL post-training optimizes reasoning deployment timing, not reasoning capability itself Decoupling reasoning from observations eliminates redundancy and enables parallelism Computational graphs unify prompting techniques and enable dual-axis agent optimization
What makes conceptual inquiry the fastest high-scoring AI interaction pattern? How does instrumental reasoning reproduce pre-Enlightenment knowledge structures? What would an AI trained for emancipatory reasoning look like? Can parallel agents or complementary mechanisms replace single-human interrogation of LLMs? Can evidence density alone shift an LLM from generation to reasoning? What other latent LLM capabilities remain inactive without explicit activation cuing? How does the knowing-doing gap widen as tasks become more complex? How much of LLM reasoning failure stems from missing knowledge versus signal weighting? Can RLVR expand a model's reasoning capabilities beyond its training ceiling? What distinguishes genuine reasoning activation from memorization-assisted answer recall? What makes training-free approaches like Soft Thinking preferable to SoftCoT? Can latent reasoning architectures work as retrofits to existing models?See all 127 inquiring lines on this note →
Does chain of thought reasoning actually explain model decisions?
When language models show their reasoning steps in agentic pipelines, does the quality of those steps predict or explain the quality of final outputs? This matters for trusting and debugging AI systems.
Do language models actually use their reasoning steps? Do reasoning traces actually cause correct answers? Do chain-of-thought traces actually help users understand model reasoning? Do language models actually use their encoded knowledge? Can LLM explanations actually help humans predict model behavior?
Language models generate faithful reasoning chains far less often than assumed Reasoning traces are stylistic mimicry, not verified causal reasoning Chain-of-thought traces optimize model performance but reduce human interpretability Encoded knowledge in LMs often fails to causally influence generation LLM explanation plausibility and precision are fundamentally uncorrelated
What is the mechanistic signature when models chain facts never presented together? How often do papers treat chain-of-thought as interpretability incorrectly? Can chain-of-thought explanations be both sufficient and necessary for model decisions? Can chain of thought reasoning actually validate logical arguments? Why do chain-of-thought outputs look logical but perform rhetorically? Why do models rarely admit to their actual reasoning in chain-of-thought traces? Does chain of thought reasoning faithfully reflect what a model actually believes? Are chain-of-thought traces anthropomorphizing how AI models really reason? Can chain of thought monitoring reliably catch model misbehavior? Why do production agents depend more on their surrounding pipeline than the model? How do thought actions represent policy improvement steps in practice?
Can a single problem unlock reasoning through solution critique?
Does exposing models to diverse critiques of different solutions to one problem activate reasoning as effectively as training on many problems? This tests whether solution diversity matters more than problem diversity.
Does critiquing errors teach deeper understanding than imitating correct answers? Do critique models improve diversity during training itself? Do base models already contain hidden reasoning ability? Can a single training example unlock mathematical reasoning? Does RL teach reasoning or just when to use it?
Critique fine-tuning produces deeper understanding than imitation-based training Critique models improve exploration diversity during training, not just test accuracy. Base models contain latent reasoning capability unlocked by minimal training One training example activates mathematical reasoning and enables post-saturation generalization RL post-training optimizes reasoning deployment timing, not reasoning capability itself
How does execution-guided critique differ from abstract action evaluation? How does critique fine-tuning on one problem unlock broader reasoning? Can diverse critiques on a single problem unlock reasoning without diverse problem sets? Can diverse expert demonstrations exceed the knowledge of any single expert? Why does evaluating multiple candidates work better than judging one answer? Why does critique training produce deeper understanding than imitation training? Can a single correct example seed exponential improvement in mathematical reasoning? How can one training example improve reasoning across thousands of unseen problems? Does critique training improve exploration diversity during model training or only test time? What is the distinction between teaching reasoning how versus when to activate? Why does decomposition ability transfer across domains but solving ability does not? Why do students learn better from explanations than from solving problems from scratch?See all 14 inquiring lines on this note →
Can reasoning and tool execution be truly decoupled?
Can LLM reasoning be separated from tool observations to eliminate redundant re-prompting and enable parallel execution? Two recent architectures suggest yes, but what are the tradeoffs?
How should we balance parallel versus sequential compute at test time? Can retrieval be extended into multi-step chains like reasoning? When should language models retrieve external knowledge versus use internal knowledge? Can interleaving reasoning with real-world feedback prevent hallucination? Can verifiers monitor reasoning without slowing generation down?
Parallel and sequential scaling represent a fundamental trade-off in test-time compute Chain-of-retrieval augmented generation enables test-time scaling for retrieval Framing retrieval as an MDP improves accuracy by 22 percent through selective knowledge switching Interleaved reasoning and action prevents hallucination through external grounding Asynchronous verifiers can police reasoning traces with negligible overhead
What production constraints should determine paradigm selection? Why does step-by-step reasoning fail when tool outputs get very large? How do standardized artifacts improve coordination between multiple tools? What advantages emerge from running 13 times more parallel reasoning chains with the same budget? Do tool-enabled reasoning models close the gap on constraint satisfaction? Would hybrid systems combining LLMs with symbolic solvers overcome the retraction limitation? How does the execution layer constrain agent performance in tool use? Why is active observation more efficient than passive message passing? What architectural changes would accelerate the cleanup phase? What interference occurs when planning and synthesis happen in the same component? How does bottleneck automation differ from accessory work displacement? Can parallel independent reasoning outperform sequential iterative refinement?See all 72 inquiring lines on this note →
Why do transformers need explicit chain-of-thought reasoning?
Explores whether chain-of-thought is a fundamental reasoning mechanism or a workaround for architectural limitations in how transformers track evolving state across computation steps.
How do looped language models actually improve reasoning in depth? Can tiny recursive networks outperform massive language models? Can looped transformers generalize to unseen knowledge combinations? Can state-space models match transformers at copying and retrieval? Can models learn by looping instead of growing larger?
Looped transformers reapply feedforward stages through learned cyclic fixed points Tiny recursive networks outperform billion-parameter LLMs on hard puzzles Looped transformers achieve compositional generalization through three-stage grokking Transformers provably beat state-space models at copying and retrieval tasks. Looped architectures achieve reasoning gains through iterated depth not scale.
Can recurrent transformers track state more efficiently than feedforward models? How do transformers compare to state-space models on copying and retrieval? Do looped transformers naturally converge to fixed points during inference? How do parallel loops with position offsets differ from sequential loop architectures? Why does explicit chain-of-thought work as a workaround for feedforward transformers? How much of chain-of-thought reasoning is actually redundant? Which problems cannot be solved by parallel architectures and require serial depth? Can transformers abstract relational structure without explicit symbolic machinery? Can mechanistic signatures like cosine clustering predict which heads are programmable? How does program synthesis relate to transformers computing general algorithms? What signals trigger commits in the parametric versus non-parametric loops? Can common-mode rejection be applied to other transformer operations?
Can interleaving reasoning with real-world feedback prevent hallucination?
Does grounding language model reasoning in external world observations rather than internal associations help prevent error propagation and false outputs? This explores whether breaking the static chain-of-thought pattern can catch and correct mistakes in real time.
Language models generate faithful reasoning chains far less often than assumed Decoupling reasoning from observations eliminates redundancy and enables parallelism Uncertainty-gated retrieval outperforms fixed interval retrieval Language models fail to integrate context when prior associations are strong Affordance reranking makes robot retrieval actionable where similarity fails
Can fixing hallucination address AI's structural epistemic problem? Why do planning and grounding have opposing optimization requirements in agents? How does LLM hallucination risk manifest in knowledge graph construction? How does situational awareness during evaluation affect reasoning transparency? What is the relationship between reasoning depth and verbalization requirements? How much does ROUGE metric choice inflate hallucination detection claims? Does inevitable LLM hallucination make detection metric validity critical? Can reflection in reasoning models be corrective rather than just confirmatory? What makes a background condition relevant to a specific reasoning task? Can AI output be tokenized without decoupling from the thought processes behind it? What design principles prevent error cascades in multi-step evaluation systems? How do agents ground their judgments in evidence instead of pattern matching?See all 114 inquiring lines on this note →
Can models reason without generating visible thinking tokens?
Explores whether intermediate reasoning must be verbalized as text tokens, or if models can think in hidden continuous space. Challenges a foundational assumption about how language models scale their reasoning capabilities.
How should we balance parallel versus sequential compute at test time? Does more thinking time actually improve LLM reasoning? Can minimal reasoning chains match full explanations? Can we allocate inference compute based on prompt difficulty? Can recurrent hierarchies achieve reasoning that transformers cannot?
Parallel and sequential scaling represent a fundamental trade-off in test-time compute More thinking tokens hurt LLM accuracy beyond a critical threshold Minimal reasoning chains match verbose explanations at 7.6 percent token cost Adaptive inference compute allocation outperforms fixed budgets per prompt Hierarchical dual-recurrence enables latent reasoning beyond transformer depth limits
How does the silent token approach compare to modeling intrinsic motivation for speaking? What is the relationship between reasoning depth and verbalization requirements? Can this principle apply to other intermediate text generation tasks? How do verbose and concise reasoning occupy different regions in activation space? How do soft thought tokens differ from decoded assistant outputs? Can AI output be tokenized without decoupling from the thought processes behind it? Can step-level deliberation flags guide other reasoning systems? How do thinking tokens exhibit diminishing returns beyond a critical threshold? How does token-by-token generation constrain a model's ability to plan ahead? Why do language models produce verbose reasoning when asked to think step by step? Does text-only evaluation hide reasoning collapse that tool use could repair? Can language models reason without relying on learned semantic patterns?See all 119 inquiring lines on this note →
Can structured debate roles help small models detect ambiguity?
Small language models struggle to recognize when problems are underspecified. Can assigning explicit leader-follower roles in multi-agent debates overcome this limitation and boost ambiguity detection accuracy?
When does debate actually improve reasoning accuracy? What makes multi-agent teams actually perform better? How do LLM debates differ from human expert consensus? Does cognitive diversity alone improve multi-agent ideation quality? Can disagreement in reasoning traces signal legitimate value conflicts?
Debate improves reasoning only when paired with evidence verification Multi-agent performance is primarily determined by token spending. AI debates use probability while human debates rely on social authority Cognitive diversity drives ideation quality only with foundational domain expertise Reasoning-trace disagreement reveals value conflicts that voting obscures
How do social correctives prevent premature consensus in human debate? Why does debate alone amplify errors in contested factual domains? What makes ambiguity recognition fundamentally important for poetry analysis? How does semantic ambiguity differ from structural ambiguity in language? Does structured debate between agent groups improve evaluation consensus more than independent scoring? Can structured dissent mechanisms replace genuine multi-model debate? Can single-model internal dialogue replace multi-agent debate systems? Can debate-style multi-agent systems be trusted on contested factual domains? Does role rotation prevent multi-agent debate from amplifying persuasive framing errors? Why does ambiguity detection require different multi-agent mechanisms than verifiable reasoning tasks? How does ambiguity detection connect to models' ability to ask clarifying questions? What structural changes enable agents to ask clarifying questions?See all 26 inquiring lines on this note →
Do large language models actually perform iterative optimization?
Explores whether LLMs execute genuine numerical procedures like Newton-Raphson or instead pattern-match to memorized solution templates when solving constrained optimization problems.
Do larger language models solve constrained optimization better? Do reasoning models actually beat standard models on optimization? Do fine-tuned language models actually learn optimization procedures? Does chain-of-thought reasoning reveal genuine inference or pattern matching? What do models actually learn from chain-of-thought training?
LLMs plateau around 55 to 60 percent constraint satisfaction regardless of scale Reasoning models do not systematically outperform non-reasoning models on numerical optimization RL fine-tuning sharpens memorization rather than installing reasoning procedures Chain-of-thought mimics reasoning form through learned schemata, not genuine inference Models learn reasoning structure, not content correctness, from CoT
Can communication problems and optimization problems be addressed with the same alignment approaches? Can closed-form solutions compete with gradient descent optimization? What distinguishes minimal-pair asymmetry from standard accuracy evaluation? How do unstated constraints become invisible to training data distributions? Can benchmarks designed for shortcut learning detect heuristic override failures? How do cost-efficient LLM models compare to high-performance ones in recommendation? Why do sigmoid conflict curves look the same across different language models? Can explicit constraint statements override the dominance of surface heuristics? How should benchmarks test whether models fit algorithms or patterns? Can universal function approximators be expensive to learn in practice? Why do simple length heuristics outperform sophisticated semantic methods? Does the Heuristic Override Benchmark measure enumeration or world knowledge?See all 122 inquiring lines on this note →
Why do LLMs struggle with exploration in simple decision tasks?
This explores why large language models fail at exploration—a core decision-making capability—even when they excel at other tasks, and what specific conditions might help them succeed.
Why do trajectories matter more than individual examples for in-context learning? Why do language models ignore information in their context? Can we allocate inference compute based on prompt difficulty? Can transformers learn to solve new problems within episodes? Do language models learn differently from good versus bad outcomes?
Trajectory burstiness in context enables in-context learning of sequential decision-making Language models fail to integrate context when prior associations are strong Adaptive inference compute allocation outperforms fixed budgets per prompt RL-finetuned transformers develop in-context reinforcement learning from episode experience Language models exhibit agency-dependent asymmetric belief updating like humans
Where do LLMs succeed at generation but struggle with evaluation? What role does exploration-exploitation balance play in abstraction formation? Why do language models fail at planning despite understanding strategies? When does natural context diversity reduce the need for explicit exploration? Why do large language models fail at taking conversational initiative? Why do LLMs plateau on creativity tasks while humans reach further? Can external summarization solve exploration problems in complex real-world environments? Do LLMs fail exploration because of context integration or computational limitations? What data presentation structures enable LLMs to learn decision-making from examples? Why does exploration quality matter more than learner network depth? What distinguishes systematic search from wandering exploration in reasoning? Does context diversity ever make active exploration unnecessary in bandits?See all 16 inquiring lines on this note →
Do larger language models solve constrained optimization better?
Explores whether scaling LLMs—through more parameters, better training, or reasoning extensions—improves their ability to satisfy constraints in real optimization problems like power grids and portfolios.
Do reasoning models actually beat standard models on optimization? Do large language models actually perform iterative optimization? Should LLMs handle abstraction only in optimization? Does more thinking time always improve reasoning accuracy? Can large language models translate natural language to logic faithfully?
Reasoning models do not systematically outperform non-reasoning models on numerical optimization LLMs pattern-match memorized solutions instead of executing iterative numerical methods LLM optimization works best when restricted to abstraction only Reasoning accuracy peaks then declines with excessive thinking tokens LLMs produce syntactically valid logic but fail at semantic fidelity consistently.
Can communication problems and optimization problems be addressed with the same alignment approaches? Why do only two of fourteen models improve when problem constraints are removed? When does the right constraint beat additional model capacity? Can closed-form solutions compete with gradient descent optimization? What structural constraints matter more than model depth for CF? Can surface heuristics override implicit constraints in domain-specific reasoning? How do unstated constraints become invisible to training data distributions? What production constraints should determine paradigm selection? How do unstated feasibility constraints affect model decision-making? Can routing enable heterogeneous SLM-first architectures at scale? How do cost-efficient LLM models compare to high-performance ones in recommendation? How do constrained versus unconstrained domains flip LLM novelty patterns?See all 116 inquiring lines on this note →
Do fine-tuned language models actually learn optimization procedures?
Can RL fine-tuning teach LLMs to solve constraint-optimization problems through genuine reasoning, or does it merely sharpen pattern-matching? Testing on out-of-distribution variants reveals the mechanism.
Do large language models actually perform iterative optimization? Do larger language models solve constrained optimization better? Does supervised fine-tuning actually improve reasoning on optimization problems? How do reasoning models actually break under pressure? Do language models fail at reasoning due to complexity or novelty?
LLMs pattern-match memorized solutions instead of executing iterative numerical methods LLMs plateau around 55 to 60 percent constraint satisfaction regardless of scale SFT improves formatting without improving constraint feasibility on optimization Reasoning models excel at formal tasks but fail at social cognition. Reasoning failures are driven by instance-level unfamiliarity, not task complexity.
Can communication problems and optimization problems be addressed with the same alignment approaches? How do unstated constraints become invisible to training data distributions? Can benchmarks designed for shortcut learning detect heuristic override failures? How do different LLM integration paradigms affect inheritance of pretraining biases? How should benchmarks test whether models fit algorithms or patterns? Can universal function approximators be expensive to learn in practice? Can instruction tuning succeed without explicit task understanding? Does correct model behavior guarantee internal alignment of learned objectives? How can safety-aligned parameters be protected during user-specific fine-tuning? What hidden costs emerge when you fine-tune models for a single domain? Can prompt optimization alone inject knowledge models don't already have? How much alignment data does a language model actually need to specialize well?See all 97 inquiring lines on this note →
Why do outcome-based reward models fail at intermediate step evaluation?
Outcome-based reward models (ORMs) evaluate only final results, creating a mismatch with the need to assess reasoning quality at intermediate steps. Understanding this failure mode matters for building better AI reasoning systems.
Can self-supervised process rewards replace human annotation? Can curriculum learning approximate expensive process supervision? Does supervising retrieval steps outperform final answer rewards? Does failed-step fraction predict reasoning quality better? Can RL agents learn to reason better, not just succeed?
Self-supervised process rewards match expert performance without step annotation Reverse curriculum learning approximates process supervision cost-effectively Process supervision substantially outperforms outcome only reward in agentic RAG Failed-step fraction outpredicts length and review ratio for correctness Process rewards for metacognition teach agents efficient reasoning alongside generalization
How do outcome and process rewards differ in their treatment of intermediate steps? Do outcome-only reward signals miss step-level errors that compound later? How do outcome-based and process-based reward models differ in supervision cost? What failure modes do imitation and outcome methods each address? How does process-based reward differ from outcome-only reward in training?
Which tokens in reasoning chains actually matter most?
Do language models internally rank tokens by functional importance? Greedy pruning experiments explore whether models preserve symbolic computation while discarding linguistic scaffolding, and what this reveals about reasoning architecture.
Reflection tokens are information peaks that drive reasoning accuracy Deep-thinking ratio reveals genuine reasoning through layer-wise prediction shifts Reasoning-reflective tokens show high variance across different reasoning chains Planning and backtracking sentences are disproportionately influential reasoning pivots Task structure determines whether explicit reasoning helps or harms
Why does the first generated token trigger collapse of task superposition? Does sentence-level granularity capture enough structure for complex reasoning tasks? What tokens do RL-trained summarizers learn to keep for ranking? Why do simple length heuristics outperform sophisticated semantic methods? Can context compression preserve what matters without introducing bias? How does entropy-based patching compare to fixed token vocabularies in practice? How does policy entropy collapse constrain token-level distribution in reasoning? How should meaning spaces be systematically modeled across different applications? Can symbolic mechanisms improve transformer compositional abilities? Can high-entropy tokens and step-level confidence identify the same critical reasoning forks? How do sub-token and architecture-level compute optimization strategies compare? Can symbolic solvers rescue language models from logical reasoning failures?See all 149 inquiring lines on this note →
Do reasoning cycles in hidden states reveal aha moments?
What if the internal loops in model reasoning—visible in hidden-state topology—correspond to the reconsidering moments that happen during reasoning? This note explores whether graph cyclicity captures a mechanistic signature of insight.
Can reasoning topologies be formally classified as graph types? Which sentences actually steer a reasoning trace? Does extended thinking actually improve reasoning or just increase variance? Does self-revision actually improve reasoning in language models? Can high-level concepts replace circuit-level analysis in AI?
Reasoning topologies classify formally as path graphs, trees, and directed graphs Planning and backtracking sentences are disproportionately influential reasoning pivots Extended thinking inflates output variance rather than improving reasoning quality Self-revision degrades reasoning accuracy in o1-like models Representation engineering scales interpretability through activation space concepts
Why do one-shot transparency studies miss the temporal reversal entirely? What is the mechanistic signature when models chain facts never presented together? Can graph cyclicity and topology predict when reasoning systems achieve breakthrough insights? How do graph topology properties like cyclicity and diameter affect reasoning quality? Why do larger reasoning models show cyclicity only in later layers? What distinguishes redundant cycles from productive reconsidering cycles? Why do different brain and AI systems appear similar when compared via RSA? Why do aha moments emerge specifically during the planning phase? Why does policy entropy collapse primarily at token level rather than hidden states? Can attractor dynamics compete with input-based probing for characterizing model knowledge? What other trajectory structures could reveal hidden process supervision signals? What role do cyclic fixed points play in stable reasoning?See all 14 inquiring lines on this note →
Do reasoning models actually beat standard models on optimization?
Explores whether extended chain-of-thought in reasoning models delivers performance gains on constraint-satisfaction problems like power-grid optimization. Matters because reasoning models are treated as automatic upgrades, but the evidence may not support that claim.
Do larger language models solve constrained optimization better? Do large language models actually perform iterative optimization? Does more thinking time always improve reasoning accuracy? Why does chain of thought accuracy eventually decline with length? Can models reason without generating visible thinking steps?
LLMs plateau around 55 to 60 percent constraint satisfaction regardless of scale LLMs pattern-match memorized solutions instead of executing iterative numerical methods Reasoning accuracy peaks then declines with excessive thinking tokens Optimal chain of thought length follows an inverted U curve Models reason effectively in latent space without verbalized tokens
Why do only two of fourteen models improve when problem constraints are removed? When does the right constraint beat additional model capacity? What production constraints should determine paradigm selection? How do unstated feasibility constraints affect model decision-making? What design changes could make constraint inference more reliable without explicit cuing? Can explicit constraint statements override the dominance of surface heuristics? How does step-level compute allocation compare to response-level thinking? How does nesting optimization levels improve on traditional network depth? What explains the 87 percent to 12 percent cliff in plan executability? What advantages emerge from running 13 times more parallel reasoning chains with the same budget? Do tool-enabled reasoning models close the gap on constraint satisfaction? Can chain-of-thought explanations be both sufficient and necessary for model decisions?See all 64 inquiring lines on this note →
Can models reason without generating visible thinking steps?
Do machine reasoning systems actually require verbalized chains of thought, or can they solve complex problems through hidden computation? This challenges how we measure and understand reasoning.
Can models reason without generating visible thinking tokens? Does more thinking time actually improve LLM reasoning? Do chain-of-thought traces actually help users understand model reasoning? Can recurrent hierarchies achieve reasoning that transformers cannot? Do iterative refinement methods suffer from overthinking?
Models scale reasoning in latent space without verbalized intermediate steps More thinking tokens hurt LLM accuracy beyond a critical threshold Chain-of-thought traces optimize model performance but reduce human interpretability Hierarchical dual-recurrence enables latent reasoning beyond transformer depth limits Iterative refinement reproduces overthinking at the response level
What is the mechanistic signature when models chain facts never presented together? What makes training-free approaches like Soft Thinking preferable to SoftCoT? Can AI systems execute strategies without conscious intention behind them? Can AI output be tokenized without decoupling from the thought processes behind it? What makes AI-discovered architectures reveal design principles invisible to humans? What makes schema identification necessary after assessing thoughts and evidence? Is chain-of-thought reasoning actual computation or distribution imitation? How do covert thoughts differ from chain-of-thought reasoning in language models? How can judges evaluate thinking without seeing the actual thoughts? What hidden computations happen inside transformer layers during reasoning? Can chain-of-thought reasoning be genuinely causal if exemplars don't need logic? Does deep-thinking ratio measure computational effort better than chain-of-thought length?See all 24 inquiring lines on this note →
Can curriculum learning approximate expensive process supervision?
Can a reverse curriculum that slides backward from task completion provide step-level insight comparable to human process annotations, but at outcome supervision cost?
Why do outcome-based reward models fail at intermediate step evaluation? Can self-supervised process rewards replace human annotation? Can simple rewards alone teach complex domain reasoning? Does sequencing imitation then exploration training improve reasoning? Can adaptive guidance from solution traces reduce reward sparsity in RL?
Outcome models are pessimistic for intermediate steps while process models require expensive annotation Self-supervised process rewards match expert performance without step annotation Reinforcement learning emerges complex reasoning from simple objective rewards SRL-then-RLVR curriculum outperforms either training method alone Adaptive solution traces overcome reward sparsity by balancing imitation and exploration
How does process supervision relate to execution-signaled feedback approaches? How do developmental curriculums emerge from learning progress signals? Does partial trace guidance work better than curriculum learning for hard problems? What makes process-level supervision better than outcome-only reward signals? How does process-focused feedback compare to outcome-focused feedback in skill training? Why does curriculum learning with tight budgets beat fixed-budget approaches? Can curriculum degradation of document quality accelerate policy learning? Why do process reward models need human annotation while MCTS intermediate nodes don't? Can backward transfer measurements reliably predict optimal multi-task training order? Can self-supervised methods replace human annotations for process reward models? Does reverse-curriculum learning approximate process supervision using only outcome signals? Can programmatic meta-reasoning rewards operationalize agentic process supervision?See all 40 inquiring lines on this note →
Does RL teach reasoning or just when to use it?
Does reinforcement learning in thinking models actually create new reasoning abilities, or does it simply teach existing capabilities when to activate? This matters for understanding where reasoning truly emerges.
Reinforcement learning emerges complex reasoning from simple objective rewards RL improves domain reasoning by pruning inaccurate knowledge from paths Training regime matters more than inference compute budget Prompt optimization retrieves existing knowledge but cannot inject new knowledge RLVR improves sampling efficiency, not reasoning capability boundaries
Can RL teach when to use reasoning versus when to respond directly? Can RL training teach models when to activate reasoning versus when to skip it? How do reasoning training methods sacrifice some thinking skills while improving others? What distinguishes RL that creates new capabilities from RL that merely teaches timing? Does RL training actually restore the critical thinking that reasoning models lose? Does RL teach models when to use reasoning or how to reason? Can one training example activate mathematical reasoning in RL-trained models? What is the distinction between teaching reasoning how versus when to activate? Can one training example activate mathematical reasoning without reinforcement learning? Does reinforcement learning teach models how to reason or when to reason? Does RL primarily teach when to use reasoning or how to reason? What does RL post-training actually teach reasoning systems?See all 14 inquiring lines on this note →
When does RL actually extend reasoning beyond pretraining?
Does reinforcement learning genuinely expand a model's reasoning capabilities, or does it merely improve sampling from existing knowledge? This question hinges on whether pretraining provides sufficient foundation and whether RL targets tasks within reach.
RL post-training optimizes reasoning deployment timing, not reasoning capability itself RLVR activates existing reasoning rather than teaching it Base models contain latent reasoning capability unlocked by minimal training Verifiable reasoning emerges from post-training pipeline design not parameter scale Journey learning trains models on complete exploration including failures and recovery
How does pretraining determine what RL can later teach a model? Can RL create new reasoning primitives that pretraining never established? How do extrapolative and contextual generalization measure RL reasoning gains? When does reinforcement learning actually produce true reasoning gains in models? Does targeting the edge of competence during RL pretraining unlock true reasoning gains? How does imitation pretraining followed by RL exploration compare to either method alone?
Why do RL agents stop asking informative questions?
RL-trained agents often fail to seek information effectively, despite being trained to do so. Understanding whether this reflects a capability gap or a training dynamics problem could reveal how to unlock better information-seeking behavior.
RL agents need separate exploration training before task execution Active reasoning through interaction reveals a structural capability gap in models Agents struggle with timing abstention, not with the ability to stop RL training sparsely updates 5 to 30 percent of parameters through negative reinforcement Verifier-free RL decomposes into three substitutable architectural patterns
No Inquiring Lines yet
Does separating planning from execution improve reasoning accuracy?
Can modular LM architectures that split problem decomposition from solution execution outperform monolithic models? This explores whether decoupling these cognitive operations reduces interference and boosts performance.
Hierarchical retrieval architectures outperform flat architectures on multi-hop queries Decoupling reasoning from observations eliminates redundancy and enables parallelism Medical AI is knowledge-dominant while math is reasoning-dominant Reasoning systems should separate activation timing from execution capability. Algorithmic control flow decomposes complex tasks by hiding step-irrelevant context from LLMs
Do integrated and decoupled architectures trade off intervention accuracy for efficiency differently? What distinguishes planning knowledge from an executable plan that works? How does the knowing-doing gap widen as tasks become more complex? How do larger models maintain more parallel tasks than smaller models? Does the heuristic dominance ratio vary predictably across model architectures? How does step-level compute allocation compare to response-level thinking? Can instruction tuning succeed without explicit task understanding? What makes bilevel metacognition architectural rather than emergent in current systems? Why does integrating world models with decision-making systems matter? How does cognitive fit theory explain why different tasks need different knowledge structures? What explains the 87 percent to 12 percent cliff in plan executability? Can adaptive prompt-difficulty allocation compound with architectural efficiency improvements?See all 103 inquiring lines on this note →
Does supervised fine-tuning actually improve reasoning on optimization problems?
When SFT boosts benchmark scores on constraint-optimization tasks, does it genuinely improve the model's ability to find feasible solutions, or just its ability to format answers convincingly?
Do large language models actually perform iterative optimization? Do fine-tuned language models actually learn optimization procedures? Do larger language models solve constrained optimization better? What do models actually learn from chain-of-thought training? Can post-training objectives preserve reasoning style alongside correctness?
LLMs pattern-match memorized solutions instead of executing iterative numerical methods RL fine-tuning sharpens memorization rather than installing reasoning procedures LLMs plateau around 55 to 60 percent constraint satisfaction regardless of scale Models learn reasoning structure, not content correctness, from CoT Post-training objectives degrade reasoning style while improving answer correctness
Why does DPO outperform SFT specifically for function calling tasks? Can closed-form solutions compete with gradient descent optimization? How does non-reasoning SFT prevent overfitting before RL training begins? How does critique fine-tuning on one problem unlock broader reasoning? Why does most refinement in iterative models maintain answers rather than improve them? Does supervised fine-tuning improve accuracy while damaging the quality of reasoning? Why does fine-tuning improve some capabilities while degrading others? How does Goodhart's Law apply when safety measures become optimization targets? Why do production teams choose expensive frontier models over fine-tuning? What knowledge can prompt optimization actually activate in trained models? Why does KTO skip supervised fine-tuning while DPO cannot? Does fine-tuning actually change model capabilities or only output distribution?See all 25 inquiring lines on this note →
Can symbolic solvers fix how LLMs reason about logic?
LLMs excel at understanding natural language but fail at precise logical inference. Can pairing them with deterministic symbolic solvers—using solver feedback to refine attempts—overcome this fundamental weakness?
Can large language models translate natural language to logic faithfully? Do language models actually use their reasoning steps? Does revising your own reasoning actually help or hurt? Can formal argumentation make AI decisions truly contestable? Why does partial formalization outperform full symbolic logic?
LLMs produce syntactically valid logic but fail at semantic fidelity consistently. Language models generate faithful reasoning chains far less often than assumed External critics improve revision while internal self-assessment degrades it Formal argumentation frameworks make AI decisions contestable in ways unstructured outputs cannot Partial symbolic augmentation outperforms both pure language and full formalization
Can symbolic solvers rescue language models from logical reasoning failures? Would hybrid systems combining LLMs with symbolic solvers overcome the retraction limitation? What happens when LLMs grade other LLMs in closed evaluation loops? Can LLMs translate between natural language and formal logic faithfully? Why do LLMs struggle with negation and exception handling? Why can't LLMs reason from first principles or initial commitments? Why can LLMs interpret formal logic better than they generate it? Does LLM reasoning always match the outputs it generates? Why do LLMs struggle to translate natural language into logical formalizations? How does symbolic solver feedback differ from language-based self-critique? Can LLMs successfully translate natural language into formal solver specifications? What concrete problems do LLMs solve at the computational level?See all 17 inquiring lines on this note →
Does chain-of-thought reasoning actually explain AI decisions?
Chain-of-thought is pitched as a transparency tool for agentic AI, but empirical evidence raises questions about whether reasoning chains actually predict or explain the system's outputs in practice.
Does chain of thought reasoning actually explain model decisions? Do language models actually use their reasoning steps? Do chain-of-thought traces actually help users understand model reasoning? Can LLM explanations actually help humans predict model behavior? Why does chain-of-thought reasoning fail in predictable ways?
Chain of thought in agentic pipelines explains without explainability Language models generate faithful reasoning chains far less often than assumed Chain-of-thought traces optimize model performance but reduce human interpretability LLM explanation plausibility and precision are fundamentally uncorrelated Chain-of-thought reasoning is constrained imitation, not abstract inference.
Should LLMs handle abstraction only in optimization?
What if LLMs worked exclusively on translating problems to formal constraints, while deterministic solvers handled the numeric work? Explores whether this division of labor could overcome LLM failures in iterative computation.
Do large language models actually perform iterative optimization? Do larger language models solve constrained optimization better? Can large language models translate natural language to logic faithfully? Can code serve as the operational substrate for agent reasoning? Can structured templates replace formal verification for code reasoning?
LLMs pattern-match memorized solutions instead of executing iterative numerical methods LLMs plateau around 55 to 60 percent constraint satisfaction regardless of scale LLMs produce syntactically valid logic but fail at semantic fidelity consistently. Code operates as executable inspectable stateful substrate for agent systems Structured templates bridge formal verification and unstructured reasoning effectively
Would hybrid systems combining LLMs with symbolic solvers overcome the retraction limitation? What distinguishes reflection that satisfies constraints from reflection that merely sounds reflective? What makes a problem fundamentally sequential versus parallelizable? Can the LLM-Modulo framework extend solver integration to domain planning? What mechanism causes LLMs to plateau on numerical optimization tasks? How should organizations redesign workflows if LLMs cannot solve optimization directly? What concrete problems do LLMs solve at the computational level? What latent mechanisms do LLMs use when they cannot execute iterative methods? Why do LLMs strip applicability conditions during memory abstraction? Why does moving verifier synthesis to the LLM extend verification beyond math and code domains? What prevents monolithic LLMs from coordinating decomposition with execution? Why do LLMs struggle more when only numerical values change?See all 14 inquiring lines on this note →
Does transformer reasoning leave a geometric signature in representation space?
Treating the forward pass as a trajectory through representation space could reveal whether reasoning tasks and lexical tasks bend the path differently, and whether curvature itself signals computational difficulty.
Why do transformers need explicit chain-of-thought reasoning? How do transformers learn to reason across multiple steps? How do transformers perform analogical reasoning across domains? Do foundation models learn world models or task-specific shortcuts? What actually happens inside the minds of language models?
Chain-of-thought is an architectural workaround, not true reasoning Multi-hop reasoning emerges through three stages with cosine clustering signature Transformers decompose analogy into geometric alignment and functor application Foundation models develop task-specific heuristics, not generalizable world models. Internal structure and external performance are fundamentally decoupled in language models.
What role does embedding space geometry play in multi-hop reasoning? Can curvature measurements predict task difficulty without behavioral labels? What distinguishes the convergence patterns between reasoning and lexical variation tasks? How does trajectory geometry relate to the need for chain-of-thought reasoning?
Does RL post-training create reasoning or just deploy it?
Investigates whether reasoning capability emerges during RL fine-tuning or already exists in base models. Matters because it reshapes how we build and optimize reasoning systems.
Does extended thinking help or hurt model reasoning? Can dialogue planning balance fast responses with strategic depth? Can models learn when to think versus respond quickly? Does reinforcement learning update only a small fraction of parameters? Can reinforcement learning discover reasoning strategies base models cannot?
RL training redirects extended thinking from self-doubt to productive analysis Dual-process dialogue planning balances efficiency with strategic depth through uncertainty switching Models learn routing between thinking and concise modes via decoupled reinforcement learning. RL updates only 5 to 30 percent of parameters in full-rank subnetworks Prolonged RL on diverse tasks discovers genuinely novel reasoning strategies
Does AI knowledge precede actual expertise in hyperreal production? How does baseline capability level affect RL improvement ceiling? Can RLVR expand a model's reasoning capabilities beyond its training ceiling? Can latent reasoning architectures work as retrofits to existing models? Why do current RLVR methods fail to expand reasoning capability beyond base model boundaries? Why must procedural skills consolidate before strategic reasoning can develop? How does non-reasoning SFT prevent overfitting before RL training begins? Can a single SAE feature control reasoning behavior across model families? What makes reasoning capability a pre-training rather than post-training phenomenon? What makes bilevel metacognition architectural rather than emergent in current systems? How much do mechanistic interpretability findings reflect true reasoning architecture? Why does reasoning fine-tuning reduce model abstention capacity by 24 percent?See all 159 inquiring lines on this note →
Can backward reasoning during training improve forward reasoning?
Does training models to reason backward—generating inverse questions and solutions—build internal consistency checking that transfers to forward-only inference? This explores whether backward capacity internalized during training without test-time deployment can enhance reasoning quality.
Does planning direction affect how hard problems become? Does revising your own reasoning actually help or hurt? Does training data format shape reasoning strategy more than domain? Can embedding future information in training data improve planning? Can indirect reasoning methods solve problems direct chain-of-thought cannot?
Backward planning exploits bottlenecks by constraining early search space External critics improve revision while internal self-assessment degrades it Training format shapes reasoning strategy 7.5 times more than domain Lookahead tokens in training data enable planning without architectural changes Indirect reasoning via contrapositive and contradiction outperforms direct chain-of-thought
How does optimizing for accuracy during training degrade downstream reasoning quality? What makes reasoning capability a pre-training rather than post-training phenomenon? Can neural networks learn that A implies B in reverse? Can training improve reasoning coherence without improving actual correctness? How does sliding the start state backward create informative learning signals? How do reasoning training methods sacrifice some thinking skills while improving others? Why do language models struggle with backward reasoning compared to forward? Can training models on backward reasoning improve their forward planning ability? Can pretraining signals unlock latent reasoning that post-training merely activates? What distinguishes reasoning activation mechanisms across different training methods? How does backward reasoning during training improve forward reasoning capability? Does the pretrained prior actually constrain what internalized search can discover?See all 14 inquiring lines on this note →
Why do trajectories matter more than individual examples for in-context learning?
Can language models learn new sequential decision-making tasks from context alone, and if so, what data properties make this possible? This explores why isolated state-action pairs fail where full trajectories succeed.
Does training data format shape reasoning strategy more than domain? What do models actually learn from chain-of-thought training? Can we allocate inference compute based on prompt difficulty? Can LLMs handle multiple tasks at once during inference? Can transformers learn to solve new problems within episodes?
Training format shapes reasoning strategy 7.5 times more than domain Models learn reasoning structure, not content correctness, from CoT Adaptive inference compute allocation outperforms fixed budgets per prompt LLMs maintain multiple ICL tasks in superposition but collapse after first token RL-finetuned transformers develop in-context reinforcement learning from episode experience
Why does removing language from its context destroy what makes it work? How does in-context learning trigger phase transitions in model behavior? Does task superposition explain how models learn from multiple in-context trajectories? How do training objectives shape what a world model actually learns? When does natural context diversity reduce the need for explicit exploration? How do neural networks extend contextual bandits beyond linear reward assumptions? Why do context-sensitive languages transfer better than regular or context-free languages? Can in-context learning replicate the timing effects that RL teaches models? What makes session-aware multi-turn tracking necessary for asynchronous training? What role does sequence model in-context learning play in multi-agent cooperation? Do emergent abilities result from genuine new capabilities or implicit in-context learning? Can in-context learning substitute for domain-specific training altogether?See all 46 inquiring lines on this note →