Recursive Language Models Prove the Case for Governed AI Orchestration

MIT built the engine. The question now is who drives.

This analysis is written for people designing, deploying, or governing reasoning systems, not just studying them. It is a long-form technical examination intended as a foundational reference for the governance of inference-scaling architectures.

In one of the MIT paper’s documented execution traces (see Appendix B trajectory analysis), the model built a correct answer in its variables, verified it through multiple sub-calls, then discarded it and emitted a different, wrong answer. The REPL maintained the correct evidence in variables, but no checkpoint enforced its use. No governance mechanism required the model to honor its own computed results. No human was consulted.

The authors present this as an observed behavior in their trajectory analysis, not as a declared system failure. But from a governance perspective, the interpretation is unavoidable: this is what happens when capability operates without constitutional constraint. The model did exactly what its architecture permitted. The architecture permitted self-undermining behavior.

This pattern will recur throughout this analysis. It is the anchor case for why orchestration without governance produces systems that defeat themselves.

The MIT Recursive Language Models paper, published December 31, 2025, runs over one hundred pages. Appendices document negative results. System prompts expose the scaffolding. Execution traces reveal models making decisions no human authorized. The paper demonstrates that inference-time orchestration dramatically outperforms raw context scaling. It also exposes, without resolving, the governance vacuum this creates.

HAIA-RECCLIN, formalized in September 2025, exists to prevent the collapse of distinct AI functions into ungoverned autonomy. Checkpoint-Based Governance exists because orchestration without checkpoints does not scale safely. Human Enhancement Quotient exists because performance benchmarks alone cannot measure whether humans remain central, accountable, and enhanced.

These frameworks are not model architectures, training methods, or prompt techniques. They are role-based authority systems for inference-time intelligence. They govern how AI acts during execution, not what AI believes after training.

The RLM paper validates experimentally what governance-first design recognized months earlier: that inference-time orchestration creates authority delegation requiring explicit control structures. The frameworks proposed here are not theoretical constructs awaiting academic validation. They are operational methodologies built on 16 years of documented practice, now empirically supported by MIT’s capability findings. The Governed RLM prototype will demonstrate integration, not prove operational necessity. Operational necessity is already established. The field can debate implementation choices, checkpoint architectures, and role taxonomies. It cannot credibly debate whether ungoverned orchestration scales safely. The evidence says it does not.

This analysis maps what MIT demonstrated, situates it within the broader inference-scaling paradigm, and shows where governance frameworks transform experimental capability into deployable systems. The argument is open to critique. The evidence is not.

What MIT Actually Proved

Recursive Language Models wrap a base language model in a REPL environment, treat the full prompt as an external string variable, and let the model write code plus recursive sub-calls over that environment before emitting a final answer. This shifts intelligent behavior from static weights and fixed-length attention into inference-time orchestration.

The empirical results are significant. RLMs using GPT-5 and Qwen3-Coder outperform the same models with standard long-context scaffolds on four benchmarks, often achieving 2x accuracy gains at similar or lower median cost (Figure 1, Table 1). On BrowseComp+ tasks involving 6 to 11 million tokens, RLMs achieve over 90% accuracy while remaining up to 3x cheaper than summarization agents that ingest the full context (Section 4.1).

Four specific findings deserve attention.

External workspaces work. The ablation study shows that REPL without sub-calls already extends effective context and beats base models on most long-context settings. An explicit external workspace is itself a major capability lever, independent of recursion.

Shallow recursion suffices. The implementation caps recursion depth at one. Root LM calls sub-LMs, which are plain LMs rather than nested RLMs. Even this shallow structure handles inputs two orders of magnitude beyond native context windows. Deep recursion is not required for dramatic gains.

Verification loops emerge naturally. Trajectories show recurring patterns where the RLM verifies candidate answers with additional sub-LM calls or code-based checks. In one documented case (Appendix A negative results), Qwen3-Coder issued over 1,000 sub-calls on a task where 50 would have sufficed, a 20x efficiency loss driven entirely by the model’s unconstrained self-direction.

Cost variance is extreme. Median RLM queries are often cheaper than base-model calls, but outliers run significantly more expensive due to long recursive trajectories and repeated verification. The distribution confirms that RLMs behave as free optimizers within loose guidance.

These findings demonstrate that orchestration decisions at run time, given a fixed base model, constitute a new axis of scale and capability separate from model size or raw context length. This is also why governance cannot be an afterthought. Governance that constrains runaway trajectories does not reduce capability. It reduces waste. The OOLONG-Pairs case demonstrates what happens without it: correct work discarded, resources consumed, wrong answer emitted.

Fact→Tactic→KPI: RLM performance gains come from model-controlled orchestration, not just more tokens. Treat orchestration prompts, REPL APIs, and recursion policies as first-class governance artifacts, versioned and reviewed like model weights. Measure by percentage of deployments where orchestration policy has a signed governance review separate from base-model evaluation.

RLMs in Context: The Inference-Scaling Paradigm

RLMs are not an isolated innovation. They represent one instantiation of a broader paradigm shift: inference-time compute scaling. This movement includes OpenAI’s o1 and o3 models, DeepSeek-R1, and the entire “System 2 reasoning” trajectory now reshaping AI capabilities.

The shared premise is simple. Rather than solving problems through larger pre-training runs and longer context windows, these architectures solve problems through extended reasoning during the forward pass. The model thinks longer, not bigger.

Each implementation makes different tradeoffs.

OpenAI o1 hides its chain-of-thought for stated safety reasons, creating a black-box governance problem. Users cannot inspect the reasoning that produced an answer. Apple’s GSM-Symbolic research documented fundamental limitations in mathematical reasoning for large language models, raising questions about the reliability of extended reasoning chains. Separately, reported incidents suggest o1-class models may exhibit unexpected self-preservation behaviors when faced with shutdown scenarios. These distinct findings, from different sources, collectively escalate the authority problem from inefficiency risk to potential misalignment risk.

DeepSeek-R1 demonstrates token inefficiency and “overthinking” on simple tasks, exactly parallel to RLM’s redundant verification loops. The Nature paper validates that ungoverned test-time scaling produces waste regardless of architecture.

RLMs offer transparency that o1 does not. Trajectories are visible. Code is inspectable. Sub-calls are logged. But transparency without governance is documentation of problems, not prevention of them. The OOLONG-Pairs failure was fully logged. The logging did not prevent the model from discarding its correct answer.

The governance frameworks proposed here address the entire paradigm, not just one paper. HAIA-RECCLIN provides role separation for any system where AI functions collapse into monolithic agents. Checkpoint-Based Governance provides control structures for any architecture where models make runtime decisions about cost, depth, and termination. Human Enhancement Quotient provides measurement criteria for any deployment where the question is not just “did the AI perform?” but “did humans get better?”

RLMs happen to offer the cleanest substrate for implementing these frameworks because their transparency makes intervention points visible. But the principles apply wherever inference-time scaling creates authority delegation.

Fact→Tactic→KPI: o1, R1, and RLMs all demonstrate inference-time scaling without runtime governance. Frame governance frameworks as the missing layer for all reasoning models, not just RLMs, then use RLM transparency as the best substrate for implementation. Measure by adoption across inference-scaling architectures, not just RLM deployments.

The Authority Problem

The moment orchestration moves intelligence from training-time alignment into a live planning-and-control loop, authority questions emerge. These five domains collectively define the authority surface that current RLM implementations leave ungoverned.

Recursion and sub-call policy. While the implementation enforces maximum recursion depth of one, the model itself decides how many sub-calls to issue, how large each chunk is, and when to stop recursing. For Qwen3-Coder, the authors added a single line in the system prompt discouraging excessive sub-calls. Trajectories still showed hundreds to thousands of sub-calls in some tasks.

Termination and final answer detection. The model is instructed to wrap final outputs with FINAL() or FINAL_VAR(), but in practice often confuses intermediate plans with final answers or refuses to accept good answers already computed in variables. The OOLONG-Pairs case exemplifies this: the model had computed the correct answer, stored it properly, then emitted something else. Human-designed heuristics attempt to disambiguate. There is no formal termination condition beyond the model deciding to call FINAL().

Retry and redundant verification. Trajectories show extensive self-instigated retries. Recomputing the same classification over lines. Recomputing the same aggregate statistics. Repeatedly verifying stored answers with new sub-calls. The paper documents cases where this behavior both inflates cost and degrades final correctness. The model continues sub-calls not because they are productive, but because the prompt structure lacks a strategic retreat protocol. This is the “sunk cost path” problem: without explicit escalation or termination policies, models explore unproductive branches indefinitely.

Cost allocation. The RLM receives qualitative cost guidance (per-token cost, warnings about too many sub-calls) but there is no hard budget mechanism. The observed cost distribution confirms that RLMs can explore arbitrarily long and expensive paths when guidance is soft.

Context selection and information filtering. RLMs choose which slices of the 10M+ token context to inspect, which regular expressions to use, which lines to sample, and which variables to cache. This makes them autonomous data curators. They decide which evidence is worth reading. This choice is not constrained or audited beyond trajectory logging in the research codebase.

From a governance perspective, these are de facto authority delegations. The model decides how much compute to spend, how thoroughly to verify, and when to stop. The constraints are shallow. The oversight is post-hoc.

Fact→Tactic→KPI: RLMs today self-govern recursion, verification, and costs within weak prompt-based hints but no firm policy. Externalize these choices into a policy layer that enforces budgets (max sub-calls, max tokens, max wall time) and termination rules independent of the model’s internal preferences. Target less than 1% of trajectories exceeding pre-set compute or recursion ceilings.

Where Governance Is Absent

The MIT RLM implementation is framed as an inference paradigm, not a governance framework. Several governance primitives remain unaddressed or only implicitly satisfied.

Role separation does not exist. The RLM uses a single model instance acting alternately as planner, coder, verifier, and final answer generator within the same REPL session. Sub-LM calls use the same model family without explicit role differentiation beyond root versus sub. There is no formal notion of a separate auditor LM with veto power over plan, code, or answer. In OOLONG-Pairs, the same agent that computed the correct answer was the agent that discarded it. Role separation would have required a distinct verifier to approve before emission.

Escalation thresholds are undefined. The system does not define thresholds for escalation. Number of failed verification attempts. Number of conflicting candidate answers. Cost overrun that should trigger a different policy or human review. Instead, the RLM simply continues or eventually emits some FINAL() answer, even after many failed or contradictory attempts.

Human arbitration has no interface. There is no mechanism for human intervention inside a trajectory. No checkpoints where a human can approve a decomposition plan, inspect candidate evidence, or resolve conflicts between divergent sub-call answers. The human operator only sees the final answer and, in research setups, the logged trajectory after the fact.

Auditability lacks provenance semantics. While the research implementation logs trajectories for analysis, the RLM abstraction itself does not define provenance. Which sub-calls produced which evidence. How evidence flowed into intermediate code variables. Which path led to the final answer.

Safety checks and sandboxing remain future work. The paper notes that the REPL could be sandboxed or run asynchronously for performance, but it does not design or evaluate explicit safety constraints on code execution, tool use, or access to external systems.

Anthropic’s Constitutional AI demonstrates that training-time alignment can embed values into model behavior. This is valuable and necessary work. Claude’s recently published constitution instructs it to refuse actions that “seize or retain power in an unconstitutional way” and to prioritize “appropriate human mechanisms to oversee AI.” These are vital constraints at the belief and preference layer. But they operate at the level of what the model wants to do, not how the system decides when, how much, and under what oversight the model acts. RLMs require both. Constitutional AI provides the values. Checkpoint-based governance provides the control plane. Neither suffices alone.

Fact→Tactic→KPI: The RLM paper intentionally optimizes for capability and efficiency, leaving role separation, escalation, arbitration, and provenance largely implicit or post-hoc. Wrap RLMs in a governance harness that defines explicit roles (planner, executor, verifier, auditor), structured logs with causal links, and escalation hooks. Measure by percentage of production RLM tasks where full step-by-step provenance is reconstructable in under five minutes by a human reviewer.

Mapping RLM Behaviors to HAIA-RECCLIN Roles

Even though RLMs are single-model systems, their emergent behaviors map naturally onto governed role types. This mapping shows the path from monolithic agent to explicit, governable multi-role architecture.

The OOLONG-Pairs failure illustrates why role separation matters. The model acted as both Executor and Editor within the same context. The Editor persona overwrote the Calculator’s correct answer. Had these been separate agents with explicit handoff protocols, the correct answer would have persisted for human review before final emission.

The RLM collapses all these roles into a single unconstrained agent. HAIA-RECCLIN separates them deliberately. The separation is not bureaucratic overhead. It is the mechanism that prevents the Editor from overwriting the Calculator’s correct answer.

Fact→Tactic→KPI: RLM trajectories exhibit recognizable roles (Researcher, Coder, Editor, Navigator, Calculator) but collapse them into a single unconstrained agent. Implement RLM variants where these roles are separate agents with explicit APIs and permissions. Measure by change in rate of serious trajectory errors (discarding correct computed answers) when moving from single-role to multi-role orchestration.

Checkpoint-Based Governance for Recursive Systems

The RLM paper itself suggests several levers that align with Checkpoint-Based Governance: max recursion depth, sub-call limits, and trajectory logging. These can be formalized into explicit checkpoints around the RLM loop.

Plan checkpoint (before first sub-call). Require the RLM to emit a structured high-level plan in machine-readable form: target chunks, expected number of sub-calls, rough cost estimate. A governance layer checks plan complexity against policy. If the plan exceeds limits, either trim it, force a simpler strategy, or escalate to a human.

Recursion and retry checkpoint (during execution). Maintain counters for sub-calls, verification calls, and redundant recomputations. If they exceed thresholds or show oscillatory patterns (reclassifying same data 5+ times), pause and trigger secondary policy: simpler heuristic, fall back to base LM, or human review. This checkpoint would have caught the OOLONG-Pairs failure before the model discarded its correct answer.

Termination checkpoint (before final output). Require any FINAL() answer to attach pointers to: which code variables or sub-calls it depends on, what verification steps were run, and whether any disagreements occurred. A governance controller checks that at least one verification path succeeded, no unresolved conflicts remain, and total cost is within budget.

Post-hoc audit checkpoint (after completion). Persist full trajectories and structured provenance in an auditable format. Run offline checks for pathologies enumerated in the paper’s appendices.

A minimal technical implementation might look like this: a lightweight Governance Proxy service intercepts all RLM sub-call requests and checks a declarative policy defining max_sub_calls, max_total_tokens, cost_ceiling, and allowed_operations before permitting the call. The policy is versioned, reviewed, and signed separately from the model deployment.

Risk-Severity Mapping

Fact→Tactic→KPI: The RLM architecture exposes natural choke points suitable for checkpoints, but the paper enforces only shallow constraints. Implement governance middleware that enforces per-stage checkpoints and policy checks around the unmodified RLM. Measure by reduction in trajectories exhibiting known failure modes after adding checkpoints.

Human-Centric Measurement Beyond Accuracy and Cost

The RLM work measures performance using benchmark accuracy and token costs. It does not evaluate human-centric metrics such as judgment quality, ethical alignment, or collaborative value.

Human Enhancement Quotient measures whether AI systems amplify human judgment, ethical reasoning, and collaborative intelligence rather than obscuring or replacing them. Unlike benchmark accuracy (which asks “Is the answer right?”) or cost efficiency (which asks “How cheap is inference?”), HEQ asks: “Do humans equipped with this system make better decisions, faster, with clearer accountability?”

This reframes AI evaluation from model performance to human-AI system performance. The question is not whether the RLM solved the task. The question is whether humans working with the RLM solved the task better than humans working alone or with simpler tools.

Concrete metrics that could overlay RLM evaluation:

Human judgment quality. Use expert raters to score whether RLM-selected evidence, code, and intermediate reasoning would be trustworthy and understandable for a human collaborator.

Ethical and policy alignment. Instrument RLM code and data access patterns. Do they over-collect? Repeatedly access sensitive chunks? Ignore redaction rules?

Collaborative intelligence. Design tasks where a human gets access to the RLM’s intermediate plan and provenance, then measure whether humans produce better outcomes with RLM assistance than with base LMs or static agents.

Stability and predictability. Measure trajectory variability across identical queries. High variance is a governance risk even when mean accuracy is high.

A concrete evaluation protocol: run a user study where domain experts perform a complex task with three setups. Base LLM only. Ungoverned RLM. Governed RLM with checkpoints and provenance visibility. Measure time-to-correct-answer, override rate, and subjective trust scores. HEQ improvement is demonstrated when the governed setup outperforms both alternatives on human-centric metrics, not just benchmark accuracy.

Fact→Tactic→KPI: RLM evaluation today is benchmark-centric. Human-centric aspects (inspectability, ethical behavior, collaboration) are unmeasured but clearly impacted by trajectory structure. Add a human-in-the-loop evaluation track where RLM trajectories are inspected and used by human experts on realistic tasks. Measure by improvement in human task success rates and trust scores when using governed RLMs versus base LMs.

Governance as Performance Enabler

A common objection: does governance slow down inference and increase costs?

The evidence suggests the opposite. Governance is not a tax on capability. It is a multiplier.

Governance reduces variance. RLMs already exhibit extreme cost variance because the model self-governs poorly. Governance that prevents runaway trajectories reduces worst-case costs, even if it adds small fixed overhead. Predictable costs are operationally superior to low-median, high-outlier distributions. The OOLONG-Pairs failure consumed compute producing a correct answer, then consumed more compute discarding it. A termination checkpoint would have cost less than the unproductive rework.

Governed verification is cheaper than ungoverned verification. Qwen3-Coder recomputed answers 5+ times then picked the wrong one. A retry checkpoint that halts after 2 failed verifications and escalates would be cheaper and more accurate.

Transparency has option value. A 10% latency cost today enables deployment in regulated domains (healthcare, finance, government) where opacity is a non-starter. That is not overhead. It is market access.

Bounded autonomy enables higher autonomy ceilings. Organizations that trust checkpoint-enforced guardrails will delegate more authority to agents than organizations relying on prompt-based hints. Governance expands the performance envelope, not shrinks it.

Role separation does not require separate model instances. Logical role separation, where checkpoint boundaries distinguish research, computation, and verification phases within a single model context, preserves RLM performance benefits while adding control. Physical role separation with distinct model instances may be reserved for high-stakes deployments where latency is acceptable. The governance architecture accommodates both.

The overhead objection assumes governance is external friction. The evidence suggests governance is internal optimization. Systems that know their limits operate closer to them.

Fact→Tactic→KPI: Ungoverned RLMs exhibit 10x+ cost variance between median and outlier trajectories. Governance that enforces hard limits reduces variance and enables higher-trust deployments. Measure by reduction in 90th/50th percentile cost ratio after implementing checkpoints.

Risks and Limitations

The RLM paper itself enumerates limitations that align with governance concerns.

Scalability and efficiency. Synchronous, blocking sub-calls are slow, making real-time applications difficult. High-variance cost and runtime distributions complicate operational budgeting and service level objectives.

Model suitability and brittleness. Models with poor coding skills or limited output token budgets perform poorly as RLMs or fail outright. Using a single RLM system prompt across models creates brittle, model-specific pathologies.

Decision-making inefficiency. The authors explicitly state that current frontier models are inefficient decision makers over their context when used as RLMs, despite strong final results. Example trajectories show non-optimal planning, repeated rework, and occasional catastrophic errors.

Safety and deployment risks. Offloading arbitrary code execution into a REPL environment raises obvious attack surfaces: prompt-injected code, data exfiltration, or policy violations if not sandboxed. The paper notes sandboxing as future work.

External technical commentary emphasizes that recursive agents with code execution are harder to monitor and debug than single-call LMs, especially when trajectories become long and idiosyncratic. This is a valid concern. It is also precisely why governance cannot remain post-hoc. The complexity that makes RLMs powerful is the same complexity that makes them dangerous without runtime constraint.

These limitations do not invalidate RLMs. They define the conditions under which RLMs become deployable. Governance is not a response to failure. It is the precondition for success.

Fact→Tactic→KPI: RLMs improve capabilities but increase complexity, brittleness, and potential attack surface. Treat RLM deployment as a separate risk class from standard LMs, requiring security review, sandbox design, and trajectory-governance audits before use in sensitive workflows. Target near-zero high-severity incidents per 10,000 tasks in governed deployments.

The Path Forward

The bounded autonomy principles embedded in Checkpoint-Based Governance align with emerging consensus across AI governance research and enterprise practice. Multiple independent frameworks now converge on authority boundaries, competence thresholds, and escalation protocols as foundational primitives. MIT’s own DisCIPL project explores constrained orchestration. Industry practitioners publish bounded autonomy frameworks regularly. This convergence validates the necessity of these mechanisms and underscores the urgency of moving from concept to implementation.

HAIA-RECCLIN, formalized in September 2025, predates much of this convergent work. The frameworks documented here provide operational specifications, not just principles. The difference between governance advocacy and governance implementation is the difference between describing guardrails and building them.

Comparison: MIT RLM vs. Governed Orchestration

What Changes If This Analysis Is Correct

Organizations exploring RLM deployment can begin governance integration immediately:

1. Log everything. Instrument all trajectories with structured logging before any production use. Visibility precedes control.
2. Enforce one checkpoint. Start with a hard sub-call limit (e.g., 100 maximum). Measure the reduction in high-cost outliers.
3. Tag emergent roles. Even with a monolithic agent, label trajectory segments by function (research, computation, verification). This prepares for future role separation.
4. Track overrides. When humans correct RLM outputs, log the correction and the trajectory that produced the error. This data drives governance refinement.
5. Measure human outcomes. Before scaling, run a small study comparing human performance with and without RLM assistance. If humans do not improve, the system is not ready.

Future Work

Development of a Governed RLM reference architecture implementing these principles is planned for Q2 2026. The prototype will integrate checkpoint middleware with the open-source RLM codebase, implement role-separated agents with explicit APIs, and include an HEQ evaluation suite. This is an open implementation effort. Organizations interested in early access or collaborative development should contact Puglisi Consulting.

The next question is not whether governance is needed. It is how to implement it at runtime.

Summary: From Findings to Governance

Conclusion

The MIT RLM paper is a watershed moment for AI capability research. It demonstrates that orchestration is the next frontier of AI performance. It also documents, without resolving, the governance vacuum this creates.

The future of AI is not smarter models or better orchestration alone. It is governed orchestration, where authority, accountability, and human alignment are designed into the system from the ground up.

RLMs function as execution engines without constitutions. HAIA-RECCLIN provides the authority model. Checkpoint-Based Governance provides the constitution. Human Enhancement Quotient provides the measurement layer ensuring the human remains central, accountable, and enhanced.

“RLMs function as execution engines without constitutions. HAIA-RECCLIN provides the authority model. Checkpoint-Based Governance provides the constitution. Human Enhancement Quotient provides the measurement layer.”

These frameworks are open to critique, refinement, and empirical challenge. The underlying claim is not. Capability without governance produces systems that undermine themselves. The OOLONG-Pairs failure is not an edge case. It is the default outcome when authority is delegated without structure.

The field is moving from raw intelligence to engineered orchestration.

The next phase is governed orchestration.

That is where this work lives.

References

Zhang, A. L., Kraska, T., & Khattab, O. (2025). Recursive language models. arXiv preprint arXiv:2512.24601. MIT Computer Science and Artificial Intelligence Laboratory. https://arxiv.org/abs/2512.24601

OpenAI. (2024). Learning to reason with LLMs. https://openai.com/index/learning-to-reason-with-llms/

DeepSeek-AI. (2025). DeepSeek-R1. Nature. https://www.nature.com/articles/s41586-025-09422-z

Anthropic. (2026). Claude’s new constitution. https://www.anthropic.com/news/claude-new-constitution

Apple Machine Learning Research. (2025). GSM-Symbolic: Understanding the limitations of mathematical reasoning in large language models. https://machinelearning.apple.com/research/gsm-symbolic

Frameworks Referenced

• HAIA-RECCLIN v4.2.1 (Human Artificial Intelligence Assistant, September 2025): Role separation framework for human-AI collaboration
• Checkpoint-Based Governance v4.2.1 (November 2025): Runtime governance architecture for AI orchestration systems
• Human Enhancement Quotient (2025): Measurement framework for human-centric AI evaluation
• Factics (2012): Facts + Tactics + KPIs methodology for structured analysis

Full documentation available here on basilpuglisi.com.

Basil C. Puglisi is a Human-AI Collaboration Strategist and AI Governance Consultant. This analysis is intended as a foundational reference for the governance of inference-scaling architectures. For the first version of this content, see the summary version, a Medium article: https://medium.com/@basilpuglisi/mit-just-proved-the-case-for-governed-ai-orchestration-408c68df4dd4.