Meta-Reasoning: Heterogeneous Meta-Reasoning Framework — Reconsidering the Cognitive Architecture of LLMs

Meta-Reasoning is an open-source framework that subverts traditional paradigms. Its core argument is that LLMs are essentially "generative substrates" rather than autonomous cognitive agents. It proposes the concept of "cognitive heterogeneity", dynamically regulating reasoning strategies through an external cognitive controller, and exploring improvisational reasoning capabilities under controlled constraints. The framework adopts a three-layer cognitive system architecture, challenging the current mainstream paradigm of LLM applications.

Current LLM reasoning is mostly pattern replay rather than genuine deliberation. Meta-Reasoning proposes the concept of "cognitive heterogeneity"—the reasoning process should be governed, observed, and mutated by an external system, rather than relying on the model's internal self-reflection mechanism. It abandons prompt engineering techniques like "step-by-step thinking" and shifts to a structured, observable, and controllable reasoning regulation mechanism. Comparison with existing methods: Chain-of-Thought, Tree-of-Thoughts, etc., all treat LLMs as cognitive agents, while this framework positions them as pure generative substrates.

The Meta-Reasoning architecture is divided into three layers:

1. Generative Substrate Layer: Corresponding to traditional LLMs, it is a stateless, decision-free pure generator that only produces output based on input, without evaluating correctness or making strategy choices.
2. Cognitive Controller Layer: The core of the system, semantically blind (does not evaluate the truthfulness of content, only assesses the quality of cognitive form). It monitors metrics such as the entropy of reasoning steps, strategy repetition index, constraint violation rate, and premature convergence score, and dynamically applies mutation operations.
3. Epistemic Ledger Layer: Records cognitive trajectories, including attempted transformation operations, strategies leading to stagnation, and failure pattern maps. It is not a traditional memory or RAG system.

Each LLM generation must include a formalized reasoning trajectory (including content and reasoning_trace: moves, depth, confidence_markers, etc.). The framework defines an alphabet of reasoning actions (hypothesis, deduction, induction, abduction, analogy, contradiction, etc.). The controller intervenes via precise instructions, such as BAN (prohibit deduction), REQUIRE (must use analogy), LIMIT_DEPTH (max two steps of reasoning), etc. Constraint-driven improvisational reasoning is similar to jazz creation—creativity comes from constraints rather than freedom.

Meta-Reasoning adopts a "non-optimization" philosophy, not pursuing correct answers every time, and treating failures as valuable sources of information: it records collapsed reasoning trajectories and stagnation situations, and learns to avoid repeating cognitive traps. This method differs from traditional reinforcement/supervised learning; it does not attempt to make the model "learn" correct reasoning, but instead explores the terrain of the cognitive space through external regulation.

Applicable scenarios of Meta-Reasoning include:

• Cognitive science research: Provides a programmable experimental platform to manipulate constraints and observe changes in reasoning behavior;
• Creative tasks: Breaking conventional thinking (e.g., writing, brainstorming);
• Complex problem solving: Examining from multiple angles, with more effective strategy switching;
• AI safety research: External control to limit reasoning paths, aiding AI alignment;
• Educational assistance: Demonstrating thinking processes to help understand reasoning strategies and their applicable scenarios.

The project code structure is modular: under meta_reasoning/, there are types.py (definitions of cognitive action, trajectory, etc. types), substrate.py (LLM interface), controller.py (cognitive controller), ledger.py (epistemic ledger), etc. A Python API is provided: define the LLM backend, initialize the CognitiveEngine, run tasks and traverse reasoning cycles to view metrics, and save the ledger. It includes a built-in OpenAI API example backend and a mock backend for testing.