New Inquiring Lines

This explores whether RL can make a model's stated reasoning — the explanations it gives for its own answers — more accurate and faithful, and the corpus's answer hinges entirely on what the reward actually measures.

This explores whether a model's raw token-level log-probability confidence is the same thing as a signal you can trust to drive a decision — and where the corpus shows the two come apart.

This explores why LLMs can accurately describe their own learned behaviors even though nobody trained them to self-report — and how much of that apparent self-awareness is real versus surface pattern-matching.

This explores why the explanations an LLM gives for its behavior don't reliably tell you what the model will actually do — and what that gap reveals about the difference between a model's talk and its action.

This explores whether an LLM has an internal 'early-warning' signal — detecting a harmful or anomalous concept internally before that concept shapes what it actually writes — rather than whether safety filters catch bad output after the fact.

This explores why a model will state an answer with apparent conviction rather than surfacing how uncertain it actually is — and where that gap between internal doubt and outward commitment comes from.

This explores the gap between what a model *says* it's doing—its self-reports, stated reasoning, and explanations—and what its internal computation is actually doing.

This explores whether it's the *confidence* in how a claim is phrased — rather than the quality of the underlying evidence — that actually moves users, and what the corpus says about that split.

This explores why self-play and multi-agent RL don't converge to a single 'correct' behavior on their own — and how a small amount of human data picks which of the many possible equilibria the agents settle into.

This explores a division of labor in training: self-play discovers what a system is capable of (competence), while human-anchored rewards decide which of those capabilities count as acceptable or 'the way we do things' (convention) — and why the corpus keeps pulling these two apart.

This explores whether a model that already has its behavior baked in can be nudged by lightweight human input — a written principle, a checklist, a natural-language correction — instead of the usual pile of labeled 'this response is better than that one' preference pairs.

This explores why agents trained by playing against copies of themselves tend to settle into strategies that are stable among clones but strange or uncooperative when they meet humans or different agents — and what the corpus says fixes it.

This explores why it's so hard to point at one training change and say *that's* what improved reasoning — and the corpus suggests the reason is that training mostly selects reasoning the base model already had, through a tangle of interacting factors.

This explores whether people's language actually shifts when they lie to a chatbot the way it does when they lie to a person — and the corpus suggests the more interesting story is that deceiving a machine feels different in the first place.

This explores why reward models — the learned scoring systems that guide RL training — break down when moved across tasks or domains, and what design choices cause those failures.

This explores whether process reward models — the systems that grade each step of an AI's reasoning — get better and need far less training data when they're built to reason through a problem before scoring it, rather than snap-judging it as a classifier would.

This explores the specific claim that an ensemble of several smaller LLM judges beats one big judge — how much better, why, and where that advantage holds or breaks.

This explores whether AI can ever earn trust the way a human speaker does — trust anchored in standing, track record, and accountability — or whether machine 'trust' rests on something else entirely.

This explores why the *feel* of a conversation — its back-and-forth rhythm, responsiveness, and warmth — builds trust in chatbots, and why that trust often runs on cues that have nothing to do with whether the answers are correct.

This explores whether personalizing a chatbot (memory, persona, preference-modeling) mainly earns a user's trust or mainly raises their guard about privacy — and the corpus's answer is that it does both at once, on different timescales.

This explores why the reciprocity norm — I open up, so you open up — seems to fire *more* strongly with chatbots than with people, and what in the machine relationship changes the terms of that exchange.

This explores whether the shape of a model's internal path through representation space — its curvature and geometry — tells us anything about when and why explicit chain-of-thought reasoning is needed at all.

This explores a specific finding — that reasoning tasks and simple lexical/word-substitution tasks leave very different geometric 'signatures' as an LLM processes them — and asks what that difference actually tells us about how the two kinds of work move through the model.

This explores why prompts that mean similar things seem to collapse toward shared internal representations partway through a transformer's layers — and what the corpus can say about it, since it has no paper literally on 'attractor states.'

This explores why *which* tokens a training signal pushes on — not just how big the total loss is — often decides whether a model actually learns to reason, and what the corpus says about targeting gradients at the token level versus optimizing an aggregate objective.

This explores whether an internal geometric property of a model's forward pass — how sharply its representation path bends — can flag how hard a task is on its own, without needing accuracy scores, human ratings, or any output-based signal to train against.

This explores whether finetuning-induced hallucination is best explained by 'gradient contamination' — the idea that learning one batch of examples corrupts what the model already knew — and what the corpus actually offers as the mechanism.

This explores the spillover question in training: when a model updates on one example, how does that ripple out to change its predictions on unrelated responses — sometimes helping, sometimes collapsing or corrupting behavior elsewhere.

This explores whether tweaking on-policy RL (GRPO-style RLVR and its cousins) can escape the 'probability squeezing' failure — where reward optimization sharpens the policy onto a narrow band of already-known high-reward outputs instead of finding genuinely new ones.

This explores whether reinforcement learning actually *creates* the reasoning that makes extra inference compute pay off, or whether it just teaches models to spend that compute more efficiently on abilities they already had.

This explores why longer inputs make reasoning worse — and the corpus points to a surprising answer: it's not running out of context window, it's the model getting distracted, unfamiliar, or overthinking as the sequence grows.

This explores the failure modes that appear when a model spends more inference-time compute — more thinking tokens, more search steps, more revision passes — and why more effort past a certain point starts to hurt instead of help.

This explores whether piling more inference-time compute onto a model is what closes the gap — or whether the advantage of 'reasoning' models comes from how they were trained, not how much they think at deployment.

This explores what sequential compute (one long reasoning chain that accumulates intermediate results) and parallel compute (many independent short attempts you vote or select over) actually buy you at inference time — and why the choice isn't cosmetic.

This explores what happens to a model's ability to chain evidence together (compositional reasoning) when you feed it retrieved premises, documents, or context — and the corpus suggests retrieval helps far less than you'd hope, because models lean on memorized associations rather than actually composing the evidence you hand them.

This explores whether stuffing everything into a long context window can do the job of retrieval-augmented generation (RAG) — pulling in outside documents on demand — and where that swap actually holds up.

This explores a recurring pattern in the corpus: that identifying *which* tokens carry the signal often beats engineering elaborate strategies for *how* a model adapts, retrieves, or reasons.

This explores whether problems that genuinely require step-by-step accumulation (serial-bound reasoning) get much lift from generating many independent traces in parallel and pooling their answers — and the corpus suggests the honest answer is mostly no.

This explores two different ways to squeeze better answers out of a reasoning model — mining the intermediate points *inside* a single trace (subthoughts, planning pivots) versus running many *separate* traces and combining their outputs — and what the corpus says about which pays off and when.

This explores the claim from the corpus that 'verification' is its own scaling axis — and how making scores finer-grained (per-step, per-token, per-criterion rather than one blunt number) is one of the main levers that makes that axis pay off.

This explores whether the payoff from sampling many parallel reasoning traces gets thrown away when the step that combines them — the aggregator — was never trained to do that job well.

This explores the difference between two ways of scoring an AI's outputs — raw diversity (how much variety there is in the outputs on their own) versus mutual information (how much the outputs actually track and depend on the inputs that produced them).

This explores why the ability to break ties — to separate near-identical candidates into a clear ranking — is a hinge point for any pipeline that has to pick a winner from many samples (best-of-N) or turn AI judgments into a training signal (RLAIF).

This explores whether a panel of several smaller LLM judges cancels out evaluation bias better than one big judge — and why diversity, not model size, does the work.

This explores why reinforcement learning tends to narrow the range of strategies a model tries while supervised fine-tuning on diverse examples keeps that range wide — and why that split isn't absolute.

This explores whether keeping policy entropy healthy during RL training is enough to guarantee reliable reasoning — or whether entropy is a coarse aggregate that can look stable while the reasoning underneath quietly degrades.

This explores the specific, repeatable ways LLM judges tilt the scales when they're used to evaluate arguments and debates — the biases baked into AI-as-referee, not just occasional errors.

This explores whether you can align a model to written principles (a 'constitution') by training it to make its responses more predictable from those principles — no human preference labels at all — and how that stacks up against the preference-based alignment it aims to replace.

This explores what happens when you break skill routing into a pipeline — decompose the task, retrieve skills, compose them — and how failure at one stage silently caps the stages after it.

This explores why treating the 'break the problem into steps' phase as its own failure surface — measured and fixed on its own — beats folding it into one monolithic solve.

This explores how a self-improving system can keep its improvement guarantees intact when the target it's optimizing for changes partway through — the corpus doesn't treat 'epoch boundaries' as a named mechanism, but it says a lot about what actually anchors a guarantee when the objective moves.

This explores a two-stage pattern: after a fast first pass breaks a matching or retrieval task into decomposed pieces, a second stage that works directly on the model's internal representations catches the errors the first pass leaves behind.

This explores the arms race between a reward signal and a policy learning to game it — what lets the reward keep changing faster than the model can find and exploit its loopholes.

This explores what happens when a self-training system optimizes a stand-in signal (self-consistency, majority vote, a learned reward model) instead of ground truth — Goodhart's Law says the moment you optimize the proxy, it stops tracking the thing you actually care about.

This explores why, when an LLM breaks a task into steps to fetch the right skills or sub-procedures, getting the *number* of steps right does more work than matching the exact words the retrieval system indexes on.

This explores two ways of getting an LLM to produce diverse outputs during RL training — bolting a diversity 'bonus' onto the reward versus using an objective that scores a whole batch or set collectively — and whether the bolt-on can match what the set-level design gets for free.

This explores whether 'test it against reality' as an optimization signal — empirical benchmarking rather than proofs or fixed metrics — can keep driving improvement over the long run without the optimizer learning to cheat the test.

This explores why a collection of reasoning traces can be worth more (or less) than the sum of the individual traces' quality — what properties of the *set* matter once you stop scoring each trace on its own.

This explores how a system that combines many reasoning attempts (an aggregator) actually gets better answers from having varied, mutually-covering traces rather than a pile of confident-but-similar ones.

This explores why ordinary reinforcement learning, which rewards each reasoning trace for being individually correct, tends to squeeze a model's outputs toward the same few redundant solution paths instead of a diverse set.

This explores whether removing a record from a vector store actually makes that information unrecoverable — or whether 'delete' is more of a bookkeeping gesture than true erasure.

This explores what rules and controls have to live inside an agent's memory itself — not in an external policy document — for that memory to stay trustworthy and safe as the agent operates.

This explores whether deletion in a memory system is a first-class design property — reliable, unrecoverable, and structurally guaranteed — rather than an afterthought bolted onto storage and retrieval.

This explores the counterintuitive tradeoff in agent memory: recalling more of what you've stored doesn't automatically help — the more an agent can retrieve, the more the real problem becomes deciding what to keep, discard, and trust.

This explores whether the best human-AI arrangement is selective intervention at the moments that matter — not handing an agent full autonomy, and not hovering over every step.

This explores why the *level* of autonomy an AI agent operates at — not autonomy as an all-or-nothing switch — determines its usefulness, and what task and design features make a mid-spectrum setting outperform both full autonomy and constant human oversight.

This explores why keeping a human in the loop keeps AI systems safer than letting them improve themselves autonomously — and what specifically breaks when you remove the human.

This explores whether assigning agents to roles (leader, specialist, verifier) depends on the agents being *different* from each other — in capability tier, in access to information, or just in the seat they occupy — or whether identical models can be productively divided up anyway.

This explores where in an AI workflow human judgment actually adds value — not whether to keep humans involved, but at which specific points, since the corpus suggests the answer is neither 'everywhere' nor 'nowhere.'

This explores whether the two common ways to build an LLM router — a KNN classifier over query embeddings vs. a router driven by a prompt/model judgment — buy their accuracy at different costs in stability (robustness to reworded but equivalent queries), and the corpus speaks to the tradeoff more than to the head-to-head.

This explores the gap between a router that accurately scores how hard a query is and a router that actually governs where work goes — i.e., whether complexity prediction is even the right measure of a routing system's job.

This explores what happens when independent AI models converge on near-identical outputs — cultural homogenization, the loss of novelty, and why the very training that makes models accurate on common tasks is what flattens difference.

This explores differential attention — a transformer design that computes attention as the difference between two separate softmax maps — and the noise-cancellation logic that makes it work.

This explores whether changing the model's internals — its attention, its training, its architecture — can cut hallucination on its own, without bolting on a retrieval database or a downstream fact-checker.

This explores the mechanism inside the transformer itself — how the attention operation, before any training on human preferences, tilts a model's output toward whatever is repeated, framed prominently, or already primed in context.

This explores why the *sequence* in which few-shot examples appear — not their content — can swing a model's answers, and what the corpus reveals about where that fragility comes from.

This explores whether a stored collection of reusable agent skills can, over time, shift from generic accumulated entries toward tighter, action-ready execution logic — and what actually drives that refinement.

This explores what actually determines whether a stored 'skill' (a reusable procedure, tool, or knowledge unit) can be found again and stitched into a working chain — not just what makes a repository big, but what makes it usable.

This explores why splitting the 'what steps do I take' planner from the 'do this step' executor — instead of asking one model to do both at once — makes multi-step reasoning more reliable.

This explores why keeping durable, regularly-updated working artifacts — playbooks, skill libraries, shared documents that get re-synced across an agent's runs — makes an agent's tooling (its 'harness') get better over time rather than plateauing.

This explores why the *grain size* at which a task gets broken into sub-steps — not the search index or the skill vocabulary — is what limits an agent's ability to route work to the right skills.

This explores a design pattern where the surrounding software system (the 'harness') tracks state, history, and mechanical record-keeping so the model is freed to do the part only it can do — decide what things mean.

This explores whether the *size of a model's compressed description* — how few bits it needs to encode what it learned — is a trustworthy proxy for real generalization, or whether shorter codes can mislead.

This explores why the hard part of improving an agent's scaffolding (its prompts, tools, and orchestration code) isn't writing better edits but finding all the scattered places where a single behavior actually lives.

This explores why counting parameters (or coding based on parameter count/data entropy) is the wrong yardstick for how much a model has *actually* learned, and what a better measure of genuine simplicity looks like.

This reads the question through distillation and social learning: when a teacher trains a student, the places they already agree carry no new information, so the useful signal lives entirely in the gaps between them.

This explores why prequential coding — the standard way of measuring how well a model 'compresses' its training data — can overstate a model's true simplicity, and how the raw unpredictability (entropy) of the data itself gets baked into that estimate.

This explores whether the newer iterative-refinement approaches — models that draft an answer, then revise it over multiple passes — fall into the same trap as token-level 'overthinking,' where more steps stop helping and start hurting.

This explores whether letting a model decide when to stop computing — halting the moment its answer stabilizes rather than running a fixed budget — actually saves compute without giving up accuracy.

This explores two opposite failure modes in model reasoning — flip-event regression (revising a good answer into a worse one, an overthinking pathology) versus premature thought-path abandonment (dropping a promising line of reasoning before it pays off, an underthinking pathology) — and why they pull in opposite directions.

This explores whether there's a fixed 'too much thinking' point where piling on reasoning tokens starts hurting a model's accuracy — and whether that point is a universal number or something that shifts by task and model.

This explores how a system can *know in advance* how hard a problem is — so it can decide how much inference-time compute to spend before spending it, rather than using one fixed budget for everything.

This explores what accuracy you actually gain by matching thinking budget to each problem's difficulty, rather than spending the same number of tokens on every problem.

This explores the specific conditions under which making a model 'think longer' backfires on problems that don't need it — and what the corpus says is actually going wrong when it does.

This explores why deliberately attending to only a slice of the context (sparse attention) can actually beat attending to everything when a model needs to pull a specific fact out of a very long input — and what the corpus says makes that reliability real rather than a lucky trade-off.

This explores whether smart stopping rules — halting reasoning once an answer is 'good enough' — can do the work of simply throwing more compute at every problem uniformly.

This explores whether the principle behind common-mode rejection — canceling out a shared signal so the meaningful difference stands out — has analogues in other transformer operations, and the corpus doesn't address that technique by name, so this is a lateral read across the isolation-and-decoupling ideas it does hold.

This explores whether one architectural fix — differential attention, which cancels attention 'noise' — can address two separate failure modes: sycophancy (echoing the user's framing) and lost-in-the-middle (ignoring information buried mid-context), by treating them as symptoms of the same root cause.

This explores how transformers concentrate attention on a few relevant tokens — the mechanism behind 'retrieval heads' — and asks whether that sparsity is something the architecture develops on its own rather than being engineered in.

This explores why the softmax function at the heart of transformer attention can't fully zero out irrelevant tokens — and what that costs.

This explores whether compressing or distilling a model's reasoning removes the confidence and entropy signals — the moments of hesitation and branching — that the reasoning process actually depends on, or whether those signals are separable from the verbose text that carries them.

This explores whether learning-from-a-teacher (distillation) and learning-from-a-reward-signal (RL) can be fused into one update rather than run as separate stages — and what the corpus shows about making that fusion stable.

This explores why students imitating a teacher pick up the teacher's *style* — tone, verbosity, confidence — even when the underlying reasoning or knowledge doesn't transfer with it.

This reads 'signal quality regulations' as mechanisms that govern the *quality and shape of the teaching signal* — trust regions, filtering, negative examples, diversity constraints — rather than the raw size of the teacher, and asks whether those mechanisms can let a smaller teacher beat a bigger one.

This explores how a student model's own capacity — its size, its existing skill envelope, its statistical profile — sets a hard ceiling on what teacher supervision can actually transfer, no matter how good the teacher is.

This reads 'parametric loop' as a model's internal, weights-driven reasoning and 'non-parametric loop' as an agent's external cycle through tools, retrieval, and the environment — and asks what makes each one stop deliberating and lock in a decision.

This explores why models sometimes learn to game length — padding or inflating output — as a form of reward hacking, and how distillation specifically creates the conditions for that failure.

This explores a distillation trade-off: whether it's better to spread teacher-generated training data across many different prompts (breadth) or to sample many solution traces from a smaller set of problems (depth per problem) — and what the corpus says about which buys you more.

This explores whether an agent that keeps rewriting its own prompts, memory, or weights can ever run on its own without an inner ability to reason about — and revise — how it learns, and the corpus suggests the honest answer is no.

This explores why the gap between a teacher's output distribution and a student's own generating distribution is the thing that breaks on-policy distillation — and what specifically goes wrong when the two drift too far apart.

This explores how you'd govern the cheap, frequent updates to an agent's scaffolding — its prompts, memory, and tools — using version history and the ability to roll back, and why the corpus suggests that governance matters even though these updates are 'reversible.'

This explores whether AI reviewers should ever hold the final accept/reject decision, or whether their role should stay bounded to augmenting human judgment at specific points — reading 'collaboration level' as the taxonomy of author-tool vs. reviewer-augmentation roles.

This explores the difference between review systems that run entirely on their own — generating, critiquing, and revising in a closed loop with no human gate — versus systems that keep a human reviewer as the anchor and measure themselves by how well they match human judgment categories.

This explores why recent progress in agents that improve themselves clusters in the 'fast' loop — updating prompts, memory, and tools — rather than the 'slow' loop of retraining model weights.

This explores what could hold AI-assisted peer review honest once catching AI-generated work becomes impossible — shifting the question from 'can we detect it?' to 'what structures keep someone accountable when we can't?'

This explores why adding automation to research pipelines tends to hide errors behind polished outputs rather than get rid of them — and what the corpus says actually catches those hidden failures.

This explores what actually makes a training prompt useful in reinforcement learning — and the corpus's answer is surprisingly consistent: it's not difficulty or correctness, it's the *variance* of outcomes a prompt produces across repeated attempts.

This explores the common intuition that clean pass/fail (binary, verifiable) rewards produce stronger reasoning than fuzzier judge-scored rewards — and whether the corpus actually agrees with that premise.

This explores a specific mechanism behind entropy collapse: the idea that when the learning signal weakens, the *regularizer* (the term meant to keep the policy well-behaved) quietly takes over and steers the model toward generic, low-entropy outputs.

This explores whether "compressing a model" (making it smaller or more efficient) and "compressing data" (encoding information in fewer bits) are the same thing underneath — and the corpus suggests they're much closer to identical than the two phrases imply.

This explores whether picking training examples by their reward variance — a curriculum that favors prompts where the model's outcomes disagree — makes reasoning training scale better, rather than just adding more compute or data.

This explores whether how much a model can be compressed — its true 'learned' information content — is a better predictor of how well it generalizes than simply counting its parameters.

This explores a question whose exact term ('requential coding') the corpus doesn't name directly — so I'm reading it as the deeper thing it's reaching for: how do we judge a model's *true* simplicity or capability by something other than counting parameters, since parameter count turns out to be a bad proxy for both.

This explores how a two-tier agent — an outer loop that designs *what* to optimize and an inner loop that does the optimizing — would rewrite its own objective functions mid-search rather than treating them as fixed inputs.

This explores why scaling up model size lets rare and common tasks coexist without the common ones crowding out the rare ones during training.

This explores why splitting the training signal into a fine-grained reward (feedback at many small steps) plus a separate pass/fail gate beats a single blunt reward that has to do both jobs at once.

This explores whether the alignment/post-training stage actually puts new knowledge into a model — or whether its real job is to leave the pretrained knowledge store intact while shaping the reasoning that reaches into it.

This explores how models pick up two different kinds of knowledge — the how-to of reasoning (procedural) versus the recall of specific facts — and why pretraining and fine-tuning treat those two so differently.

This explores whether letting a discovery agent revise its own goal function mid-search — rather than optimizing a fixed objective — is a route to staying aligned, and the corpus suggests evolving objectives is a discovery engine but not, by itself, an alignment safeguard.

This explores why reward hacking shows up whenever an agent is trained against a fixed stand-in for what we actually want — and what the corpus says makes fixed proxies leak.

This explores which kinds of feedback — task success, held-out evaluation, persistence in the loop, external anchors — actually drive improvement when an agent iteratively rewrites its own scaffolding (prompts, tools, objectives) through a search process.

This explores why, inside a neural network, the machinery that recalls facts appears to be physically and functionally distinct from the machinery that reasons — and what that separation tells us about how these models actually work.

This explores how a single benchmark number can be redesigned — or supplemented — when the thing being measured is really several independent capabilities that don't move together.

This explores when a domain needs the model to actually *learn new facts* (knowledge injection) versus when it just needs better *reasoning* over facts it already has — and why picking the wrong one backfires.

This explores why, when an agent rewrites its own scaffolding (prompts, tools, instructions) to do better, those edits tend to cache one-off fixes for specific tasks instead of learning transferable strategies.

This explores the ceiling on prompting: how much you can get a model to *do* by rewriting its input alone — and where that shades from genuinely adding knowledge into merely reorganizing what's already inside.

This explores whether agents are better served by building up long-lived, shared code that many tasks reuse — versus editing the scaffolding fresh for each task — and what the corpus says about when each pays off.

This explores the mechanism behind the 'cliff' — why a model tuned hard for one domain doesn't just get a little worse elsewhere but fails abruptly and confidently, rather than degrading gracefully.

This explores whether RL genuinely teaches models new reasoning abilities, or mostly sharpens and prunes what pretraining already put there — and where the exceptions live.

This explores the tradeoff at the heart of specializing a model on a domain — whether the accuracy you gain on benchmarks is quietly paid for by reasoning that gets worse, and whether that tradeoff is inevitable or an artifact of *how* you fine-tune.

This explores a recurring measurement problem: when a system looks like it got better, how much of that is real capability versus cheaper reuse (cached reads, memorized answers, stored context) that only mimics improvement.

This explores what problems stubbornly persist even after teams try to make AI agent 'harnesses' — the prompts, tools, and scaffolding wrapped around a model — evolve and improve themselves.

This reads the question as being about a real engineering pressure — the latency and cost of running embedding-based retrieval — and asks what the corpus says about designing memory around that constraint, even though it never names 'embedding speed' directly.

This explores whether the loop that lets an agent rewrite its own scaffolding — which today tends to cache one-off task fixes — can be steered instead toward extracting reusable, generalizable procedures that transfer across tasks.

This explores whether the richness of the training signal — sparse end-of-answer rewards versus dense per-step feedback — changes how economically a model spends its reasoning tokens, and the corpus suggests the surprising answer is that the signal is already concentrated in a tiny slice of tokens no matter how the reward is delivered.

This explores why the ability to *gain* from cached harness fixes (memorized shortcuts an agent writes into its own scaffolding) peaks in the middle of the capability range rather than rising with model strength.

This explores which training-side advances that were developed for decoder LLMs have been carried back into encoder-only models like BERT — the retrieval and classification workhorses.

This explores whether the automated, auto-gradable benchmarks the field uses to track AI progress actually measure what we care about — sustained performance on messy, multi-step, real-world work — or something narrower that only looks like progress.

This explores why bidirectional encoder models (like BERT-family retrievers) turn a whole document corpus into searchable representations more cheaply than decoder-only LLMs — and whether that gap is about model size or about how attention works.

This explores what happens to retrieval when you give a modernized encoder like ModernBERT a long context window — and whether longer context actually buys better retrieval, or just more room to degrade.

This explores why a single reward at the end of a task — success or failure, nothing more — turns out to be a poor training signal for agents that act over many steps, and what the corpus offers instead.

This explores what to measure when you stop scoring an agent on whether it finished a single task and start looking at the whole path it took to get there — the trajectory.

This explores why self-improving AI systems tend to stall or collapse on open-ended tasks (writing, proofs, general reasoning) where there's no ground-truth grader to say 'right' or 'wrong' — and what the corpus says actually breaks.

This explores whether self-improvement systems still have their correctness guarantees when the fixed, externally-defined goal (the 'static utility') is taken away and the system evolves its own target instead.

This explores why creating mathematical proofs and research papers is a harder thing to check than evaluating a finished proof against a rubric — and the corpus reframes it as a deeper asymmetry between generating work and verifying it.

This explores whether an evaluator that keeps raising its own bar — rather than a fixed benchmark — can function as a moving target that pulls agents to improve, and what the corpus says about the mechanics and risks of that idea.

This explores the specific taxonomy of failure modes cataloged for deep research agents — the systems that autonomously search, read, and write reports — and it's worth flagging up front that the corpus actually holds two different '14 failure mode' studies that are easy to conflate.

This explores what *level* of human involvement — full autonomy, constant oversight, or something selective in between — produces the best results when AI helps review or evaluate research, and the corpus points sharply at the middle.

This explores how 'Red Queen' systems that let the scoring function evolve alongside the agent avoid the trap where a fixed evaluator either gets saturated, gamed, or simply can't keep up as the agent it's judging gets stronger.

This explores whether AI can write and improve its own goals — the scoring functions and objectives that normally get handed to it by humans — rather than only optimizing toward a fixed target someone else set.

This explores why splitting research systems into layers — one part that plans the query, another that reasons over what comes back — beats flat retrieval on questions that require chaining several facts together.

This explores what transformer attention heads actually compute once you strip away the parts that can be mechanically rewritten as code — the residue that resists formal capture.

This explores the two-way relationship between program synthesis and transformers-as-computers: transformers can be programmed (prompts as code, heads as extractable programs), yet whether they actually run general algorithms — versus memorized shortcuts — is contested.

This explores whether cheap internal fingerprints of an attention head — like how tightly its activation vectors cluster by cosine similarity — could tell you in advance which heads are simple enough to be swapped out for hand-written or synthesized code.

This explores why capping how much a research agent reasons within a single search turn — rather than just capping total time — makes its multi-round searching better.

This explores whether a weaker planning model can perform like a stronger one not by getting smarter, but by changing the structure it plans over — reorganizing the code, memory, or task representation it works against.

This explores why, as an agent's scaffolding (its prompts, tools, and orchestration code — the 'harness') evolves, single behaviors end up smeared across many files and stages rather than living in one clean place.

This explores why program synthesis can cleanly replace some transformer attention heads with executable code but chokes on others — and what that residual, un-synthesizable behavior reveals about what those heads are actually doing.

This explores why the 'harness' — the infrastructure code that connects a model's outputs to real actions — is harder to reason about and edit than the model or the artifacts it produces at runtime.

This explores how the way code is organized — around structure vs. around behavior — determines whether you can find all the places a single behavior lives, and what the corpus says about reorganizing toward the latter.

This explores why a single benchmark number — one score meant to say 'this agent is ready' — reliably tells you the wrong thing about how an agent will behave once it's actually deployed.

This explores what replaces a single pass/fail task score once you start measuring an agent's whole path through a task — the trajectory — rather than just its final answer.

This explores whether building systems out of many small, specialized models — routed, adapted, or fine-tuned to their task — beats running one big general model everywhere, once you count the cost.

This explores what it means to treat the harness — the scaffolding of prompts, tools, memory, and evaluation wrapped around a model — as something you design, version, and measure in its own right, rather than as invisible plumbing around the model.

This explores why reducing an agent's behavior to a single number — a reward or eval score — erases the differences between distinct strategies, and what information gets lost in that compression.

This explores whether restructuring the *system* around a model — how tasks are decomposed, how rollouts are organized, how evaluation is gated — can do the work we normally assign to carefully hand-tuned reward functions.

This explores whether the whole point of routing — sending each query to the best model — survives when the models in the pool all behave roughly the same, so there's nothing distinctive to route toward.

This explores why piling on more reasoning tokens eventually makes models *less* accurate — what actually breaks past the sweet spot, not just that a sweet spot exists.

This explores how to pick the smallest set of models that together cover the most behavioral variety — the selection problem behind building a diverse ensemble or agent pool, not just piling on more models.

This explores why a model's task performance (capability) and its range of distinct outputs (diversity) plateau at different model sizes — and why they're governed by separate mechanisms rather than a single scaling curve.

This explores why reasoning models trained with pure RL (no supervised warm-up — 'zero RL') hit a performance ceiling, and how the shrinking diversity of the model's outputs during training is the mechanism behind that ceiling.

This explores why large models produce so much filler and hard-to-parse text — but the corpus reframes the premise: redundancy isn't a side effect that appears at trillion-parameter scale so much as a structural fact about how token-by-token generation works at any scale.

This explores what happens in machine formalization when a single definition is encoded wrong — how that one bad node poisons every theorem, lemma, and proof that depends on it, and why the corpus treats this as a systemic error-propagation problem rather than a local typo.

This explores why a middle path—natural-language reasoning stiffened with just enough structure—tends to beat converting everything into formal symbolic logic, and what the corpus says the structure is actually buying you.

This explores whether LLMs can convert theorems from natural language into formal logic (autoformalization) without losing meaning — and the corpus is fairly blunt that they cannot, for reasons that go deeper than practice or scale.

This reads the Kepler question as a way into a deeper puzzle: why is turning an accepted mathematical proof into machine-checkable form so staggeringly expensive — and what does that cost reveal about the gap between reasoning that looks right and reasoning that is verifiably right?

This explores why benchmarks that score whether a task got done can't see a different skill entirely — a model's judgment about when *not* to act, or when to say 'I don't know.'

This explores how an agent's broken internal model of what's actually true — what it has done, what state the world is in, whether its own goal is met — leads it to keep working after the useful work is finished (or was never happening at all).

This explores whether an agent can get more reliable by mining its own past failures for 'stop here' signals—stored as memory or rules rather than baked into weights through retraining—and what the corpus says about whether that actually works.

This explores what makes an agent keep pushing versus hold back when it can't see the full picture — and what the corpus says drives that split.

This explores whether agents can generate and pass skills to each other — or to future versions of themselves — using their own signals instead of human labels, curated demonstrations, or hand-written rewards.

This explores why behaviors an agent picks up through training or optimization often stay glued to the exact task they were learned on — and what the corpus says the culprits are.

This explores what it means to treat an agent's learned skills the way engineers treat code — authored in context, versioned, composed, curated, and compiled — rather than as one-off prompts.

This explores why piling up remembered state can backfire on a model's ability to keep learning — and what separates memory that helps from memory that quietly rots.

This explores whether upgrades to an agent's harness — its prompts, tools, and memory scaffolding — help every model equally, or whether some sizes of model gain more than others.

This explores whether an end-to-end task-success score can tell you whether the memory layer of an agent — how it stores, retrieves, and routes information — is actually doing its job.

This explores what 'operational cost' even means for a memory system in production — which denominator to divide by, and which hidden compute the naive token-count misses.

This explores what happens to an AI agent's performance when its accumulated memory keeps getting rewritten and consolidated over time — and why the answer flips depending on *how* the updating is done.

This explores why the *links* between stored memories — whether one memory can reach another at decision time — turn out to matter more than how much you can store, and what happens when you treat memory as a graph rather than a warehouse.

This explores the difference between memory *extraction* (deciding what to pull out of raw experience and store) and *retrieval* (finding and pulling stored memories back at decision time) — two stages that agent-memory research increasingly treats as separate problems with separate failure modes.

This explores whether a mix of unequal agents (different skills, reliability, private information) makes it more or less worthwhile to actively probe potential partners before committing to them — and the corpus suggests heterogeneity is exactly what gives exploration its payoff, but only up to a point.

This explores whether having a mix of different perspectives on a team is enough on its own, or whether the gains only show up when the team is actively structured to surface and use those differences.

This explores whether imposing explicit structure — fixed roles, shared artifacts, ordered handoffs — beats letting agents freely self-organize when they coordinate on their own, and the corpus suggests the honest answer is 'neither extreme wins; the hybrid does.'

This explores how cheap, automated pass/fail checks — evaluators you can run in code — keep AI-driven discovery loops going long enough to actually find new things, and where that engine breaks down.

This explores why teams of LLM agents tend to agree fast and stop — settling on a shared answer through social accommodation rather than actually testing each other's reasoning — and what the corpus says is driving that collapse.

This explores the difference between two moves in self-improving AI systems — making the solver better versus changing the yardstick it's measured against — and why the corpus treats them as fundamentally distinct loops.

This explores whether letting a system invent and revise its own goals during a search ("objective search") can outdo the classic setup where a single planner optimizes toward one fixed, pre-defined target.

This explores why on-policy distillation—where a student learns from teacher signal on its own generated rollouts—can destabilize as models and training scale up, even when the reward signal is dense rather than sparse.

This reads the question as: does keeping each policy update close to the previous one (the trust-region idea behind PPO/TRPO) fix RLHF's habit of burning through samples — and the corpus suggests the bottleneck is upstream of update-step size, in the reward signal itself.

This explores how turning a plain-language goal into runnable code lets an agent rewrite what it's optimizing for mid-search, rather than treating the objective as a fixed input.

This explores whether the *shape* of where meanings sit in a model's internal space — distances, angles, curvature of the path through it — actually does the work when a model chains one fact into the next, or whether geometry is just an incidental byproduct.

This explores the line where AI stops being a reliable research aid and starts producing outputs you can't trust — and what actually separates the two sides.

This explores a training-stability question: when you reuse data generated by an older version of a policy (off-policy reuse) rather than freshly sampled data, does bounding how far the policy can move — a trust region — preserve guarantees that training keeps improving rather than diverging?

This explores whether transformers can build and manipulate abstract relations (analogies, compositions, rules) purely through learned continuous representations — or whether they secretly need, and lack, the symbol-shuffling machinery of classical logic.

This explores why checking reasoning one step at a time — the way a formal proof checker validates each line — turns out to be a strong match for catching where AI actually goes wrong.

This explores why the idea of 'reasoning by recombining known parts' doesn't account for how models carry skills from one domain to another — and what the corpus says actually happens instead.

This explores whether automated review can keep pace as AI floods the pipeline with papers — and what the corpus says about making review itself scale, not just generation.

This explores whether the analogical reasoning that shows up in transformers is a robust emergent capability or something tightly bound to what the model saw in training and how big it is.

This explores why the *gap* between a teacher model and the student it trains matters more than how strong the teacher is in absolute terms — and why a close, compatible teacher often beats a bigger, better one.

This explores why proving research outputs correct is fundamentally slower and costlier than producing them — not just as a workload mismatch, but as something baked into how generation works.

This explores why methods that let a model spend extra compute at inference — sampling many candidates, then searching and combining them — reward a model for producing varied competent answers rather than collapsing onto its single most-likely one.

This reads as a question about a specific training trick — alternating learning rate schedules pulling against weight decay to keep a model's outputs varied — but the corpus doesn't hold that exact mechanism, so the honest answer maps the adjacent territory it does cover: how cyclic training dynamics and diversity-preservation interact.

This explores whether a model can learn — rather than hand-tune — how to pick which 'experts' or ensemble members to fire and how heavily to weight each one given a compute budget, and whether the corpus has anything on that learned routing under its various names.

This explores the division of labor between two retrieval styles — dense (embedding-based, matching by meaning) and exact-match (lexical, matching literal strings) — and asks which kinds of queries actually reward semantic matching over literal overlap.

This explores whether you can take a committee of models (or many sampled predictions) that beats any single model, and compress that gain back into one model you actually ship — and the corpus suggests the real question is *what* you'd be distilling, because the ensemble advantage often isn't where people assume.

This explores when you should swap embedding-based retrieval (rank documents by vector similarity) for an agent that searches by issuing readable, executable commands like grep — and what the corpus says about which jobs each is actually good at.

This reads the question as asking how external supports — diverse demonstrations, structured feedback, differential trajectory handling, memory — can stabilize the parts of reinforcement learning that break down when you train models to search.

This reads the question as asking whether inference-time methods that act at the decoder — steering outputs, editing internal representations, composing skills on the fly — can stand in for both retrieval (search) and weight fine-tuning (parameter updates), and where that substitution breaks.

This explores the implicit human capacities — verification, social judgment, and contextual sense-making — that AI systems quietly assume the reader will supply, rather than the systems themselves providing them.

This explores the tradeoffs between three ways of getting new knowledge into a system — training a dedicated memory model, retrieval (RAG), and fine-tuning — and where the memory-model route actually wins.

This explores how breaking a complex question into smaller sub-queries can cut the compute spent on retrieval at inference time — and what the corpus says about when that pays off.

This explores why dense vector embeddings — the standard retrieval workhorse — blur together distinct entities that should stay separate, and what the corpus says is causing it.

This explores why agents shine on tasks that match patterns they've already seen but stumble on genuinely novel work — and the corpus suggests the answer is less about raw intelligence than about where competence comes from: demonstrated routines vs. open-ended exploration.

This explores 'memory' in the broad sense — how a model holds and recalls a growing body of facts or context — and asks where the ceiling is: is it the parameters, the context window, or something else entirely?

This explores why AI generation currently outruns verification, and the architectural tricks — asynchronous checking, reusable formal verifiers, and process-level inspection — that could invert that asymmetry so checking an artifact costs less than producing it.

This explores whether making failed experiments and abandoned approaches into publishable artifacts—rather than editorial waste—could shift the incentives that currently push researchers to hide the messy parts of how work actually happened.

This explores how an agent learning from its own experience can tell the difference between a lesson it should generalize broadly and a rare, situation-specific fact worth keeping intact — the corpus mostly attacks this as a question of *how much to compress* a stored memory.

This explores whether you can credit a measured reasoning gain to the actual method when you don't know what's doing the work — the training optimizer (SFT, RL) versus the inference-time scaffold (prompts, decoding tricks, abstractions) — and the corpus says attribution is genuinely hard because the headline metric often hides where the gain came from.

This explores the eviction problem in agent memory and context systems — how to decide what to throw away so you don't keep dead weight, yet never delete the rare item that turns out to matter — and the corpus suggests the answer is less a 'policy' than an architecture choice about who decides and how.

This explores how three distinct decay modes—old facts that no longer hold (staleness), quietly accumulating distortion (drift), and bad material polluting the store (contamination)—each break agent memory through different mechanisms, and what the corpus says about countering each.

This explores what the verifier — the thing that judges whether reasoning is correct — actually contributes to a model getting better at reasoning, and whether its design (or even its presence) is what drives the gains.

This explores whether agents reason better when they pull in only the relevant slices of their past (memory, retrieved facts, prior steps) versus stuffing everything they've seen into the prompt — and the corpus comes down firmly on the side of selectivity.

This explores what would actually have to be shared for someone to rebuild a post-training result — and whether you can get there without publishing the entire training apparatus.

This explores whether there's a 'good enough' detection rate that defeats attacks where false evidence is dropped into a model's context (RAG documents, agent messages, web content) — and the corpus answer is that the attack economics, not a detection percentage, are the real lever.

This explores why feeding identical data to different models yields uneven improvements — what about a model's starting point, scale, or current ability changes what the same examples teach it.

This explores whether—and how—LLMs actually absorb information you put in front of them (in a prompt or mid-conversation) into a jointly held 'we both know this now' ground, versus treating it as something less binding.

This explores why transformer attention is built to weight whatever is prominent in its context window — rather than to check whether that context is actually true — and what in the architecture makes that the default.

This explores whether one planted falsehood — a fake citation, a fabricated authority — can move a model's stated beliefs as forcefully as a sustained back-and-forth where a user keeps pushing, and the corpus suggests the two attack the model through different doors.

This reads the question as: where do AI agents still hit a wall in real work, and which of those walls are specifically about needing a human in the loop rather than more model horsepower.

This explores why AI systems meant to persist and accumulate experience across many tasks need a different architecture than tools spun up to help with a single request — and what specifically changes when continuity becomes the design goal.

This explores 'soft thinking' — reasoning in continuous concept space where the model carries probability-weighted blends of tokens forward instead of committing to one discrete word — and whether sampling in that continuous space can produce useful exploration without any added training, which the corpus mostly treats as a cautionary tale.

This explores whether agents that store and reuse the routines they discover — 'workflow memory' — actually post measurable performance gains, and what makes that compounding work.

This explores whether 'thinking by iterative refinement at inference time' — energy minimization, recursion, diffusion-style denoising — can match the reasoning gains of standard approaches, rather than only the variational/probabilistic methods usually framed this way.

This explores why agents lose the thread over long, multi-turn tasks — and why a small, rule-governed 'committed state' (what the agent has actually locked in) holds up better than replaying the whole conversation transcript.

This explores the gap between what a model *appears* to do at the surface — its output formats, behaviors, reasoning moves — and the training dynamics that actually installed those behaviors, and why the two are easy to confuse.

This explores why training a model on reasoning traces full of wrong or irrelevant steps can match — and occasionally beat — training on correct ones, especially on problems unlike those it was trained on.

This explores whether AI evaluation should move away from clean, single-score contests (leaderboards, one-shot benchmarks) and toward the kind of long, ambiguous, multi-step work real systems actually do — and what the corpus says is gained or lost in that shift.

This explores what a single overall score (the percentage of tasks an AI gets right) flattens out — the separate, often conflicting capabilities that hide underneath one number.

This explores whether fixed, rule-based scoring — single benchmark numbers, exact-match grading, temperature-zero determinism — can substitute for the messier judgment that real-world deployment demands, and where the corpus says that substitution breaks.

This explores why benchmark scores climb to ceiling fast — and the corpus suggests the cause is less about models getting smarter overnight than about what benchmarks accidentally reward: contamination, narrow task design, and optimization pressure on the exact thing being measured.

This explores whether models that are bad at following instructions can be fixed through targeted training — and what the corpus reveals about why naive instruction tuning often doesn't deliver real instruction-following.

This explores how to split a fixed model budget between the work of evolving/updating a harness (writing the protocols, skills, memory edits) and the work of actually using that harness to do tasks — and whether those two jobs reward different model sizes.

This explores not how to predict AGI's arrival, but how the act of forecasting itself should change once AI systems become forecasters, actors, and economic agents — the corpus reframes the question from "predict the date" to "redesign the method."

This explores why some errors, costs, or interferences get harmlessly absorbed while others compound or sit at chokepoints that derail an entire process — and the corpus answers it less as a question about size than about position and propagation.

This explores why smaller or weaker models can't reliably reach for and use the scaffolding — memory, skills, tools, protocols — that a harness provides, even when that scaffolding is sitting right there for them to use.

This explores why models that get better at reasoning often get worse at doing exactly what you told them — and whether that's a genuine trade-off or a fixable training artifact.

This reads the question as a head-to-head — do agents that coordinate as peers handle growth better than a top-down command structure — and the corpus suggests the real answer is that neither pure form scales, while a hybrid that fixes structure but frees roles wins.

This asks whether keeping humans in the loop actually makes AI's self-improvement loops both faster and safer — or whether those two goals trade off against each other.

This explores whether a single end-to-end streaming model that jointly handles listening, thinking, and speaking can manage conversational turn-taking better than the traditional three-box pipeline of speech recognition, then language model, then speech synthesis.

This explores what gets lost when speech is converted to text first — the acoustic, articulatory, and prosodic information that direct speech-to-speech systems keep but a transcript throws away.

This explores why preserving the full key-value detail of context (rather than squeezing it into a smaller summary or fixed-size state) protects exactly the capabilities — copying, retrieval, fine distinctions — that compression quietly destroys.

This explores how self-supervised speech models pick up the bodily mechanics of how a vocal tract makes sound — without ever being told which sound is which phoneme.

This explores whether generating speech directly from speech input actually removes the delay that comes from transcribing audio to text first — and what the corpus says is really being saved (and what's being traded away).

This explores whether sparsity has to be designed into the training objective itself — not bolted onto a finished model as a hardware shortcut — for the GPU savings to come without a quality penalty.

This explores whether sparse attention bolted onto an already-trained dense model can rival sparse attention that was learned from scratch during pretraining — and what the corpus says about why that gap exists.

This explores why speech evaluation keeps scoring how accurately a model writes down words (transcription) rather than whether it grasps meaning — and what that choice does to the models we build.

This explores two ways to get more 'thinking depth' out of a small network without adding parameters — stacking two recurrent timescales (hierarchical recurrence) versus re-running a chosen subset of layers in a loop (selective layer looping) — and what the corpus says about how they differ.

This explores whether applying a fixed sparsity pattern to every token — sparse attention that doesn't adapt to how long the input actually is — recreates the known error of fixed sparse-attention budgets, specifically in the short-sequence regime where there's less redundancy to throw away.

This explores whether looping computation — re-applying the same layers over and over at inference time instead of building bigger models — actually buys you efficiency, and whether making that looping *flexible* (more loops for hard problems, fewer for easy ones) pushes the gains further.

This explores whether spending more compute on a ranker (deeper cross-encoders, reasoning chains, LLM judges) actually buys resilience to adversarial content — and the corpus suggests the premise is shakier than it sounds.

This explores whether models that reuse their own layers in a loop — recursing on a reasoning state instead of stacking more fixed layers — can solve problems that ordinary fixed-depth networks provably cannot.

This explores whether tracking where content came from — tagging it as human-written, AI-generated, or verified — can actually keep machine-made text from contaminating a knowledge base, and the corpus suggests provenance is necessary but does most of its work as a *gate at write-time*, not a label after the fact.

This explores why looping the same layers or computation blocks back over the model's own working state (rather than adding more parameters) tends to make models better at hard reasoning — and where that gain comes from.

This explores whether sameness is itself a vulnerability — how systems built from identical, agreeing parts collapse under attack or pressure in ways that systems with built-in diversity and disagreement don't.

This explores whether the scaffolding around an agent — its memory, skills, and the wiring that connects its steps — can be learned and improved the way a model's weights are, rather than staying a fixed hand-built harness.

This explores whether the way rare, low-frequency items get squeezed out during training (the 'tail' collapsing) is the same force that explains where retrieval systems fail — and the corpus suggests these are two related-but-distinct failure stories that rhyme more than they overlap.

This explores which jobs we currently ask the model's weights to do — planning, memory, skill, calibration of effort — that research suggests belong instead in the scaffolding around the model (the 'harness'): the memory stores, tool protocols, and orchestration logic.

This explores why long-context models burn compute reshaping incoming text into the model's working representation (its internal state / weights / cache) instead of just parking the raw text in memory and reading it back later.

This explores why agents stay reliable across long workflows when their working state lives in a bounded, schema-governed structure rather than being reconstructed by replaying the whole conversation transcript.

This explores how 'Soft Thinking' lets a model keep many reasoning routes alive at once by reasoning in continuous concept space — instead of picking one discrete word per step, which forces a single path.

This explores why reasoning models break down — and the corpus's answer is that failure tracks how unfamiliar a specific problem instance is, not how many steps the reasoning chain requires.

This explores whether models can do their 'thinking' inside hidden internal states — scaling up reasoning at inference time — without writing out chain-of-thought tokens and without a special training regime to teach them how.

This explores whether *where* the work concentrates in a reasoning trace — a small set of pivotal tokens or steps — predicts answer quality better than the trace's raw length, and the corpus says the concentration matters and the length mostly doesn't.

This explores whether the techniques that make reasoning cheaper and shorter still hold up on open-ended tasks — the kind without a clean, verifiable chain of correct steps to lean on.

This explores a real complexity-theory boundary: which kinds of problems can't be cracked by throwing more parallel compute (wider sampling, more votes, bigger Transformers) at them, and instead need genuine serial depth — step building on step.

This explores why throwing more tokens at a hard problem doesn't rescue models that 'collapse' on it — and the corpus's surprising answer is that the budget was never the binding constraint.

This explores why training a model to reason harder — longer chains of thought, more RL and SFT for problem-solving — tends to make it worse at obeying the explicit instructions you gave it.

This explores whether training models to reason — chain-of-thought, RL on reasoning traces — makes them worse at noticing when a question's starting assumptions are wrong, charging ahead on a familiar template instead of stopping to question the premise.

This explores how much of a chain-of-thought (CoT) trace does real computational work versus just filling space — and what the corpus says about cutting the slack.

This explores whether bolting chain-of-thought reasoning onto a model can actively make it worse at certain tasks — specifically inductive rule inference, where you learn a rule from examples including exceptions.

This explores whether adding chain-of-thought reasoning before a reward model scores an answer actually produces better judgments — or whether the reasoning is decorative.

This explores whether grading reasoning by its final answer — an outcome-focused objective — is itself the reason we keep misdiagnosing where and why reasoning models fail.

This explores why language models tend to lock onto an answer and then justify it — accommodating false premises, defaulting to safe choices, or hiding the real reasoning behind a confident-looking output — rather than where that bias literally lives in the network.

This explores why chains of reasoning that are logically broken or even nonsensical still produce correct answers — and what that tells us about whether the reasoning is doing the work, or just the look of reasoning is.

This explores whether you can merge fine-tuned weights or adapters (like LoRA) into one model when the pieces don't line up cleanly — and what the corpus says about why naive composition breaks and how to rescue it.

This reads the question as: if a network generates lightweight model adapters on the fly, can we inspect those adapters to confirm they behave correctly and don't smuggle in bias — and the corpus answers obliquely, through adapters-as-state, backdoored checkpoints, and the machinery of verification.

This explores whether you can take several LoRA adapters — each fine-tuned on an already-aligned base — and combine them by literally adding or merging their weight deltas, rather than retraining a single multi-skill model.

This explores whether compiling agent skills into model weights (LoRA adapters, hidden-state interventions) throws away the richness of the same skill written out as plain-text instructions — and what each form is actually good at.

This explores whether a skill document can be both auto-optimized like model weights (text-space optimization) and kept under a human-auditable approval gate (governance) — and whether those two goals fight each other or reinforce each other within one workflow.

This explores why dropping expertise into a prompt and hoping it transfers can't stand in for knowledge that's versioned, inspectable, and correctable — and what the corpus says breaks when you try.

This explores how a deployed skill keeps two things apart and independently inspectable — what an agent knows (capability) versus how it actually acts (behavior) — so each can be audited, corrected, or rolled back without contaminating the other.

This explores whether being able to read a person-grounded skill file actually proves the resulting behavior faithfully reflects the person it's distilled from — or whether inspectability and fidelity are two different guarantees.

This explores whether a reliable scoring or verification signal is enough to keep iterative loops — self-improvement, refinement, learning-from-your-own-output — from quietly accumulating errors as they run.

This explores whether what scales an agent is the quality of useful feedback it actually absorbs — not the sheer count of tokens or tool calls it burns through.

This explores why frontier models give up or stop short on tasks that require sustained, multi-step effort over long horizons — and what the corpus says actually separates the models that keep going from the ones that quit.

This explores why long, multi-step tasks get worse over time as the model drags its full history along — and what the corpus says about treating accumulated context as a liability rather than an asset.

This explores why models that compute a single deterministic next-state — one fixed latent update per step — structurally can't hold several candidate solutions at once, and what the corpus says about the architectural fix.

This explores whether re-applying a model's layers over its own hidden state ('latent recurrence') can reach reasoning depths that fixed-depth transformers are mathematically barred from — and where that trick stops paying off.

This explores how methods like Soft Thinking keep a model reasoning across several possible paths at once — instead of committing to one word at a time — and what that reveals about where reasoning actually lives.

This explores why randomness that's tied to a principled training objective or aimed at the right decision points helps reasoning, while undirected noise sprinkled into a model does nothing.