Why Bigger Controllers Alone Will Not Deliver Long-Running AGI

When people talk about AGI, they often focus on one variable: the size or intelligence of the central model. The usual assumption is simple. Make the controller larger, and the whole system will eventually become generally capable.

This paper argues that this view is incomplete.

For long-running AI, the real unit of intelligence is not a single predictor. It is a workflow. A deployed system has to choose tasks, break them into smaller steps, call tools, keep records, replay earlier results, pass audits, maintain usable memory, and preserve certified capabilities while the environment changes over time. In that setting, a stronger controller is helpful, but it is not enough on its own.

That is the central claim of Controller Scale Is Not Enough for Long-Running AGI: A Workflow Theory with Reusable Certified Libraries. The paper asks a sharp question: if memory, replay capacity, validation throughput, and maintenance resources are fixed, can scaling the controller alone force long-running AGI? Its answer is no. Under explicit limits on replay and validation, controller-only scaling cannot achieve robust certified coverage of a changing target environment [1].

This is not an anti-scale argument. The paper does not say that larger models are useless. It says something more precise and more operational: once non-controller bottlenecks become binding, adding controller capacity alone will hit a ceiling. In a real system, intelligence is constrained not only by reasoning quality, but also by whether the system can reliably preserve, verify, relaunch, and maintain what it has already learned.

That shift matters because long-running AI is closer to software operations, engineering workflows, and autonomous service systems than to a one-shot benchmark. A system that works for one prompt is not the same as a system that can keep working for weeks or months under drift, tool changes, audit requirements, and maintenance load. If old capabilities cannot be replayed, if new claims cannot be validated fast enough, or if stored capabilities decay faster than they are repaired, then performance will not accumulate in a durable way.

The paper therefore proposes a workflow-level view of AGI. In this view, the relevant question is not whether a model can sometimes solve hard tasks, but whether a workflow can maintain broad, reliable, certifiable coverage over a changing task environment. That is a stronger and more realistic standard for production AI, agentic AI, autonomous software systems, and long-horizon reasoning systems.

A key contribution is the idea of reusable certified libraries. In plain language, these are not just cached outputs or compressed memories. They are reusable modules with explicit audited semantics. They come with replayable traces, witness data, launch metadata, and certification logic that can be checked again later. This makes them structurally different from generic memory, vector retrieval, latent summaries, or unaudited memoization. The difference is important: ordinary memory may help a system act faster, but certified libraries help a system preserve trusted capability.

The positive side of the paper starts here. Once a task family has a bounded typed structure, the controller burden can saturate above an interface threshold. In other words, once the controller is large enough to route across the relevant interface vocabulary, further progress comes less from making the controller even larger and more from improving workflow design. The paper identifies the ingredients of that design: protected replay, reserved validation capacity, proof-carrying composition, monitored local contract tables, novelty control, and maintenance discipline [1].

This is one of the paper’s most useful insights. It suggests that the path to stronger long-running AI may look less like endlessly scaling a monolithic brain and more like building an organized, auditable, tool-using system with stable reusable parts. That perspective connects AGI research to software engineering, reliability engineering, service operations, workflow orchestration, and AI governance.

The paper also makes a stronger comparison than the usual “modular beats monolithic” slogan. It does not compare a structured workflow to a deliberately weak baseline. Instead, the flat direct-control baseline is allowed to use the same tools, generic memory, retrieval-compression, latent summaries, caches, and memoization. Even then, without reusable audited semantics, it can certify only a bounded amount of structured target mass. The formal point is that uncertified reuse cannot substitute for audited reusable modules when replay and validation are the true bottlenecks [1].

This distinction becomes especially concrete in the repository-maintenance example. The paper studies a stylized but realistic family of software maintenance tasks such as dependency upgrades, CI repair, configuration migration, and schema repair. These tasks are not arbitrary; they have bounded typed local structure. Because of that structure, they can be externalized into reusable certified modules. The result is not just incremental improvement. Under the same total budget, the reusable-library workflow can certify exponentially larger structured slices than a flat direct-control workflow without reusable audited semantics [1].

That is a strong result because software maintenance is exactly the kind of domain where long-running AI is likely to matter first. Real-world AI agents are already being asked to debug code, manage dependencies, migrate schemas, repair tests, and maintain repositories over time. These are workflow problems. They require memory, validation, tool use, and maintenance. They are not solved by controller intelligence alone.

For AGI discussions, the broader implication is clear. If we want systems that remain useful over long horizons, we should stop treating intelligence as a single scaling curve. The relevant system has multiple coupled budgets: controller, replay, discovery, validation, and maintenance. Above a certain threshold, the problem becomes one of allocation and organization, not just raw model size. That is a more scientific way to think about durable capability.

For AI safety and governance, the paper also offers a practical advantage. Its trusted base is explicit. Instead of hiding reliability inside an opaque end-to-end system, it spells out what must be trusted: the audit rule, the registry checker, replay codecs, and observable maintenance logic. That makes the framework closer to real auditing and accountability than many informal AGI narratives.

For practitioners, the lesson is straightforward. If you are building long-running AI agents, autonomous developer tools, enterprise AI workflows, or persistent service systems, do not ask only how to make the controller smarter. Ask how the system stores certified results, how it reuses them, how it validates new claims, how it handles novelty, and how it maintains old capabilities under drift. Those are not peripheral engineering details. In this framework, they are part of the core mathematics of intelligence.

The most important sentence in the paper may be its simplest one in spirit: the relevant scaling object for long-running AGI is not an isolated controller. It is a workflow.

That claim is timely. Much of today’s AI conversation is still dominated by model size, benchmark scores, and one-shot demonstrations. This paper redirects attention toward the architecture of durable capability accumulation. Its message is not that scale stops mattering. Its message is that scale must be embedded in a workflow that can preserve, certify, and maintain competence over time.

If that framing is right, then progress toward AGI will depend not only on bigger models, but on better systems: systems with reusable certified libraries, auditable composition, protected replay, maintained memory, and workflow-level discipline. In that sense, the paper offers not just a critique of controller-only scaling, but a constructive design theory for long-running AI.

Reference

[1] Takahashi, K. (2026). Controller Scale Is Not Enough for Long-Running AGI: A Workflow Theory with Reusable Certified Libraries. Zenodo. https://doi.org/10.5281/zenodo.19690749

Author’s research hub https://kadubon.github.io/github.io/