How does the knowing-doing gap widen as tasks become more complex?
This explores the gap between what a model can *state* (declarative knowledge — 'knowing') and what it can *carry out* (procedural competence — 'doing'), and why that gap seems to grow as tasks get harder.
This question is really about the difference between knowing and doing — a model can recite the right approach yet fail to execute it, and the corpus suggests that what *looks* like complexity widening the gap is often something more specific underneath. The clearest framing comes from work treating this as a declarative-vs-procedural split: Can language modeling close the knowing-doing gap in AI? shows that LLMs hold plenty of declarative knowledge but only develop genuine procedural competence when their language-guided policies are refined by environmental feedback. In other words, 'knowing' and 'doing' are stored and learned differently, and nothing automatically converts one into the other.
A surprising thread is that the gap may not widen with *complexity* at all, but with *unfamiliarity*. Do language models fail at reasoning due to complexity or novelty? argues that models don't break at some difficulty threshold — they break when an instance drifts away from patterns they've seen. They fit instance-based patterns rather than generalizable algorithms, so a long, 'hard' chain succeeds fine if it resembles training data, while a short novel one fails. This reframes the whole question: as tasks get more complex they also tend to get more novel, and it's the novelty, not the raw difficulty, that exposes the doing-deficit. Does longer reasoning actually mean harder problems? reinforces this — reasoning trace length tracks how close a problem sits to training schemas, not how hard it actually is, so the model's 'effort' is really recall in disguise.
There's also a mechanical reason doing degrades even when knowing is intact. Does separating planning from execution improve reasoning accuracy? finds that when one model must both plan and execute, the two interfere — and pulling them apart improves accuracy, with planning ability transferring across domains while solving ability doesn't. So complexity widens the gap partly because it forces planning and execution to compete for the same limited process. Relatedly, Does reasoning ability actually degrade with longer inputs? shows accuracy falling from 92% to 68% with just a few thousand tokens of padding — well below any context limit. The 'doing' erodes simply from having more to hold, independent of whether the model still 'knows' the answer.
A quieter but striking finding is that some of what we call 'knowing' was never understanding in the first place. Does instruction tuning teach task understanding or output format? shows models trained on semantically empty or even wrong instructions perform almost identically to those trained on correct ones — what transfers is the shape of the output, not comprehension of the task. If a chunk of apparent competence is really format-matching, it's no wonder it collapses the moment a task demands real procedure. And Does procedural knowledge drive reasoning more than factual retrieval? explains why the doing-side is the scarce one: factual recall leans on narrow document-specific memorization, while genuine reasoning depends on broad, transferable procedural knowledge that's harder to acquire.
The hopeful corner of the corpus is about closing the gap rather than just diagnosing it. Beyond the RL approach above, Can agents learn reusable sub-task routines from past experience? shows agents gaining 24-51% by extracting reusable sub-task routines — with *larger* gains as the train-test gap widens, i.e. exactly where the knowing-doing gap bites hardest. And Can modular cognitive tools unlock reasoning without training? lifts GPT-4.1 on competition math from 26.7% to 43.3% with no extra training, purely by isolating reasoning operations into modular calls — evidence that much of the 'doing' capability already exists but needs structure to be reliably enacted. The throughline: the gap widens with complexity less because models stop knowing, and more because doing depends on familiarity, clean separation of planning from execution, and procedural structure that complexity strips away.
Sources 9 notes
Think-In Games demonstrates that when LLMs generate language-guided policies refined by environmental feedback, they develop procedural competence while retaining explainability. The approach dramatically reduces data demands and makes agent reasoning transparent at every step.
LRMs don't break at complexity thresholds but at instance-novelty boundaries. Models fit instance-based patterns rather than generalizable algorithms, so any reasoning chain succeeds if trained on similar instances, regardless of length.
Controlled A* maze experiments show trace length correlates with difficulty only in-distribution but decouples entirely out-of-distribution. Trace length primarily reflects recall of training schemas, not adaptive computation.
Modular architectures with separate decomposer and solver models outperform monolithic LLMs, with decomposition ability transferring across domains while solving ability does not. The separation prevents planning-execution interference and produces more generalizable skills.
FLenQA shows reasoning accuracy drops from 92% to 68% at just 3000 tokens of padding, far below context window capacity. The degradation is task-agnostic, uncorrelated with language modeling performance, and persists even with chain-of-thought prompting.
Models trained on semantically empty or deliberately incorrect instructions achieve comparable performance to those trained on full correct instructions, achieving 43% vs random baseline 42.6%. The semantic content of instructions appears largely irrelevant; what transfers is knowledge of the output space.
Analysis of 5 million pretraining documents shows reasoning relies on broad, transferable procedural knowledge from diverse sources, unlike factual recall which depends on narrow, document-specific memorization of target facts.
Agent Workflow Memory induces sub-task routines at finer granularity than full tasks, abstracts example-specific values, and compounds them hierarchically. This produces 24.6% relative gain on Mind2Web and 51.1% on WebArena, with larger gains as train-test gaps widen.
Four cognitive tools implemented as sandboxed LLM calls improved GPT-4.1 on AIME2024 from 26.7% to 43.3% without any RL training. Modularity enforces operation isolation that pure prompting cannot guarantee, eliciting pre-existing reasoning capability.