LLMs Don't Need Better Reasoning — They Need a Heuristic Inventory
Agent systems today are stuck in a local optimum: tight loop constraints keep them stable but prevent the exploration that produces real judgment. Second-order abstraction offers a path out by letting constraints grow from operational experience rather than being hand-coded once and left to rot. For anyone building RAG pipelines or autonomous agents, the core insight is that retrieval and decision-making share the same underlying problem — distinguishing noise from signal across both frequency and value axes — and a single hot-cold, counterfactual-driven mechanism can address both.
When an LLM agent picks a refactoring plan, it defaults to the safest blend or the shiniest paper — not because it can't reason, but because it has no principles to reason from. Humans navigate ambiguity with compressed heuristics like "three strikes and you refactor" or "question the problem before the solution." LLMs lack this heuristic inventory entirely, so every decision is a cold start constrained by tight anti-loop budgets that punish exploration. The fix is second-order abstraction: a pipeline that masks context to force divergent guessing (priors), exposes context to converge on evidence (posteriors), and uses counterfactual pushes to actively hunt low-probability, high-value signals. The resulting heuristics are verified by reverse coverage — 60–80% means the pattern was learned; 100% means memorization. These heuristics then feed a recursive metacognition layer that audits which principle was used, detects conflicts, and re-abstracts the conflicts themselves into meta-rules. The same masking/exposing mechanism applies across three surfaces: RAG retrieval (hot-cold layering plus divide-and-conquer recall), decision steering, and axiom-conflict adjudication. Conflict is not a bug — it is raw material for the next abstraction layer, and the recursion bottoms out when condensation yields no new patterns.
Positioning heuristic inventory as the missing piece — rather than reasoning depth — reframes the entire agent-building problem from "make the model smarter" to "give the model a memory of principles."
The 60–80% reverse-coverage validation threshold is a clever operationalization of the bias-variance tradeoff applied to rule extraction: it explicitly bakes in a generalization margin.
Treating conflict as raw material for higher-order abstraction turns a system-maintenance headache into a self-improving engine, which is a genuinely recursive architecture rather than a flat rule base.
The hot-cold memory system's two-axis design (temperature for frequency, Shannon self-information for value) solves a real RAG failure mode — rare but critical entries being permanently buried by similarity search — that most production systems ignore.
Grounding the argument in Gigerenzer's ecological rationality and de Groot's chess studies gives the framework a cognitive-science backbone that distinguishes it from ad-hoc prompt-engineering folklore.
The distinction between skill (executable sequences) and second-order abstraction (transferable judgment criteria) maps cleanly onto the difference between libraries and values, which is a useful lens for evaluating any agent architecture.