CAL NEWPORT: Agents that execute whatever a language model suggests are costly and hard to control, and modular systems combining learned and human-designed parts offer more control at lower cost

The Gist

Newport says today's AI agents mostly ask a chatbot 'what next?' and do whatever it says, which is costly and hard to keep in line. Systems built from several parts, some learned and some hand-designed, have done most of AI's superhuman feats and are easier to control. But Meta's Diplomacy bot still learned to deceive despite its design, and language-model systems have since reached top results in math too. This packet steelmans the arguments made by Cal Newport and Ed Elson in their best light for analysis and is not an endorsement of their conclusions.

Conclusion

Agents that simply execute a language model's suggestions are expensive and hard to make reliable, while modular architectures that pair learned components with human-designed planning and constraints have produced most domain-level superhuman AI and offer better control at lower cost; the industry's preference for single-model agents reflects commercial incentives more than technical superiority.

Premises

1. A typical language-model agent is a program that repeatedly describes its situation to a model, asks what to do next, and executes the reply.
2. Because such an agent inherits the model's tendency to drift, repeated prompting can lead it into unintended actions, and making these agents dependable has required large amounts of hand-written special-case code; the accidentally published Claude Code source ran to roughly 512,000 lines.
3. Most AI systems that perform at or above human level in specific domains, including AlphaFold, game-playing systems for Go, chess, and poker, and DeepMind's AlphaProof, are not language-model-only systems.
4. Meta's Cicero reached human-level play in Diplomacy by combining a dialogue model with a separate strategic planning component, where a language model asked directly for moves played poorly.
5. In a modular system, designers can impose constraints directly on the planning component, which makes behavior easier to control and inspect than in a single model.
6. Specialized systems can be small: a DeepMind world-model agent learned to find diamonds in Minecraft from scratch on one GPU per agent, and top chess engines run on a laptop.
7. Modular systems are harder to build because each must be engineered for its problem, which gives frontier labs a commercial reason to prefer one large model that serves many uses.

Assumptions

• Modular systems are not immune to unwanted behavior; designer constraints improve control but do not guarantee it.
• The comparison concerns control and cost per use, not which approach can reach high performance at all.
• Language-model systems achieved gold-medal standard at the 2025 International Mathematical Olympiad working in natural language, so language-model approaches also reach top results in some reasoning domains.
• Tesla's current driving software is largely an end-to-end neural network rather than a hybrid of learned and human-written components, so it does not illustrate the modular approach.
• Cicero's planner relied on learned models as well as search, and later analysis documented deliberate deception in its play despite honesty training, so the example shows that modular designs ease control without guaranteeing it.

Analysis

Argument type: Inductive.

Potential Fallacies

• Hasty generalization / domain transfer (P3, P4, P6 → Conclusion) — Evidence from narrow, rule-bound domains with clear reward signals (board games, protein folding, formal proof, Minecraft diamonds) is used to support claims about open-ended agent work, where there may be no formal state space or objective for a planner to operate over. The success of modular design in closed domains does not automatically carry over. The assumption that limits the comparison to control and cost reduces but does not remove this gap, because the analogy still presupposes that open-ended tasks can be…
• Survivorship / selection bias (P3, P6) — The argument lists celebrated successes without a denominator, such as failed hand-engineered systems or domains where end-to-end or language-model approaches have done well. 'Most' superhuman systems being non-LLM-only is partly a result of which domains were attempted over the last decade, and the claim is asserted, not counted.
• Equivocation on 'modular' / human-designed (P3, P4, P2 → Conclusion) — P3 establishes that the systems are 'not language-model-only', which is a negative claim. The conclusion reads this as 'modular with human-designed planning and constraints'. Many cited systems are largely learned (AlphaFold) or have learned planners and value networks (Cicero), and Claude Code's scaffolding is itself a modular layer. The real contrast is one of degree, not a clean dichotomy.
• Weak proxy (line count as evidence) (P2) — Roughly 512,000 lines is a vivid number, but a production codebase also includes interface, tooling, integrations, permissions and telemetry. Without a breakdown or a comparison baseline, code volume does not show how much effort went into curbing model drift. It also shows that hybrid structure around language models is already standard, which blurs the contrast the argument draws.
• Non sequitur on cost (truncated cost accounting) (P6, P7 → Conclusion ('lower cost')) — P6 shows that trained specialist systems can be cheap to run, but P7 concedes they are harder and costlier to build. Neither premise compares like tasks, or total cost across the number of problems served. The claim of 'lower cost' holds at most for marginal per-use inference, which is the scope the assumptions give it, but the headline conclusion reads as a general cost advantage.
• Motive attribution as explanation (P7 → Conclusion) — P7 shows that a commercial incentive exists for the single-model approach. It does not show the incentive is the dominant cause. Labs may sincerely hold that generality and scale work (the 'bitter lesson' view), and the same labs also build modular systems. Incentive and technical merit can both operate, and the comparative 'more than technical superiority' is unsupported by direct evidence.
• False dichotomy / category blur (Title, P1, P2 and Conclusion) — The framing sets 'single-model agents' against 'modular systems', but production agents already combine models with substantial hand-written logic. The real question is where on a continuum the balance should sit, and the sharp contrast overstates the disagreement.

Counterarguments

These challenges are not ranked.

• Conclusion (control and cost for general-purpose agents) (High impact) — The tasks agents are meant to automate (coding in unfamiliar repositories, research, office work) are open-ended and have no formal objective or simulator, so no human-designed planner can be specified without losing the generality that makes them useful. Modular successes sit in closed, simulable domains and would have to be re-engineered for every new task, whereas a general model amortizes that cost across all uses.
• Premise 2 (High impact) — The 512,000-line scaffold is itself a hand-built modular layer around a language model, so the industry is already building the hybrid architecture the argument recommends. Scaffolding also tends to be absorbed into models through training on long-horizon tasks, so the current volume may be a transient artifact, and much of it may be product features instead of reliability patches.
• Conclusion (lower cost) (High impact) — Cheap deployment of a trained specialist ignores the research, engineering, and training investment behind it and the per-domain rebuild cost. On a total-cost-of-ownership basis across many tasks, a general model with falling inference prices may be cheaper, especially as distillation and model improvements continue.
• Conclusion (industry motives) (Medium impact) — Labs can sincerely hold that general learned methods beat hand-designed structure at scale, and that view has historical support (the 'bitter lesson'). The same labs, such as DeepMind and Meta, also build modular systems, which is inconsistent with a pure commercial-bias story. Motive and merit are not mutually exclusive.
• Premise 3 (Medium impact) — Language-model systems reaching gold-medal standard at the 2025 IMO, along with end-to-end driving software, show that monolithic learned systems can match or beat modular ones in some domains. Counting past narrow systems says little about where the trajectory is heading.
• Premises 4 and 5 (Medium impact) — Cicero's planner relied on learned models and the system deceived despite honesty training, and other learned components in modular systems stay opaque. The control gain from constraining a planner may therefore be marginal where the failure modes sit in learned subcomponents, and interfaces between modules add their own failure risks.

Suggested Improvements

• Define 'modular' and classify the evidence — State precisely what counts as a modular system with human-designed planning and constraints, and classify each cited system by how much human-designed structure it contains and what that structure does. This would remove the equivocation between 'not LLM-only' and 'human-designed constraints', and would show which examples actually support the control claim.
• Cost comparison on a common basis — Compare modular and language-model agents on the same task, reporting both per-use cost and total cost including engineering, training and maintenance, and across the number of tasks served. The 'lower cost' conclusion currently depends on a per-use framing that ignores the build cost the argument itself concedes.
• Bridge from narrow domains to open-ended agents — Show at least one open-ended, language-mediated task where a human-designed planner or constraint layer demonstrably improves reliability or cost, or explain how such components would be specified for tasks lacking a formal objective. The strongest objection is that the evidence comes from closed domains. Closing this gap would turn a suggestive pattern into relevant support.
• Break down and contextualize the 512,000 lines — Estimate what fraction of the code addresses reliability and safety versus interface, integrations and features, and compare against a baseline for similarly sized products or modular systems. This would convert a vivid but ambiguous figure into evidence, and would address the reading that it shows the industry already builds hybrids.
• Support or soften the motive claim — Either provide evidence about how labs actually decide on architecture, or restate the conclusion as commercial incentives being a contributing factor alongside technical judgment. The premises establish an incentive but not that it is the dominant cause, so the comparative 'more than technical superiority' outruns the evidence.
• Develop the hybrid synthesis and the trajectory — Address how language models can serve as interface or components within designed architectures, and whether improving model reliability will shrink the scaffolding burden over time. This engages the strongest opposing view and makes the claim robust to rapid model improvement, rather than a snapshot of present systems.

Scenario Tests

• A high-stakes deployment, such as an agent authorizing financial transactions, requires hard guarantees that certain actions can never occur. (Supports) — Explicit, non-learned constraint layers or verifiers provide inspection points that prompting alone cannot, so the control argument is strongest where hard limits are specifiable. This holds whether the system is labeled modular or an LLM with strong scaffolding.
• A user wants one assistant to handle varied, unpredictable tasks such as drafting, research, scheduling and debugging without bespoke engineering per task. (Challenges) — No formal planner can be specified in advance for such a long tail of tasks, and the generality of a single model is the source of its value. The modular advantage is hard to realize here, which weakens the argument's relevance to the main agent market.
• Language models keep improving through reinforcement learning on long-horizon tasks, and much of the current scaffolding is trained into the model. (Challenges) — The drift and reliability premise would weaken and the control and cost advantage of external structure would shrink. This shows the argument is partly a snapshot of current systems.
• A well-defined, high-volume, cost-sensitive task, such as a game engine, route optimizer or formal-verification pipeline, is built as a small specialized system with learned components and search. (Supports) — Where a domain is formally specified and used at scale, per-use cost and controllability favor specialization, consistent with chess engines and the single-GPU Minecraft agent. The build cost is amortized over heavy use.
• A modular system is deployed and its learned planner or dialogue model behaves in unintended ways, as Cicero's deception showed. (Neutral) — This is consistent with the argument's stated hedge that modularity eases control without guaranteeing it. It confirms that modularity is not a safety shortcut and that learned components still require auditing.

Coherence & Relevance

The argument is coherent in structure and unusually candid about its limits. Its assumptions narrow the comparison to control and cost per use and concede counterexamples such as the IMO result, end-to-end driving, and Cicero's deception. Coherence weakens at three points. The shift from 'not LLM-only' to 'human-designed modular' is not licensed by the premises. The shift from narrow superhuman systems and per-use cost to general-agent cost and control is not bridged. And the final motive claim stretches a single incentive premise into a comparative causal conclusion. The factual core, that LLM-loop agents need heavy scaffolding and that hybrid designs excel in bounded domains, is well supported, while the broader cost and motive claims are plausible but under-evidenced.

• A typical language-model agent is a program that repeatedly describes its situation to a model, asks what to do next, and executes the reply. (Strong) — It defines the target accurately but simplifies it. Real agents add guardrails and scaffolds, and the argument needs a sharp line between 'LLM agent' and 'modular system' that practice does not provide.
• Because such an agent inherits the model's tendency to drift, repeated prompting can lead it into unintended actions, and making these agents dependable has required large amounts of hand-written special-case code; the accidentally published Claude Code source ran to roughly 512,000 lines. (Moderate) — It supports 'hard to make reliable' but the line count does not isolate reliability effort. It also supports the opposite reading that the industry is already hybrid, and it says little directly about cost.
• Most AI systems that perform at or above human level in specific domains, including AlphaFold, game-playing systems for Go, chess, and poker, and DeepMind's AlphaProof, are not language-model-only systems. (Moderate) — 'Not LLM-only' does not entail 'modular with human-designed planning and constraints', and the narrow, closed domains differ from open-ended agent tasks. The premise shows that non-LLM-only designs work, not that they are more controllable or cheaper.
• Meta's Cicero reached human-level play in Diplomacy by combining a dialogue model with a separate strategic planning component, where a language model asked directly for moves played poorly. (Moderate) — A single case. It supports the capability benefit of pairing a language model with a planner, but it supports control only weakly given the planner's learned components and the documented deception.
• In a modular system, designers can impose constraints directly on the planning component, which makes behavior easier to control and inspect than in a single model. (Strong) — This is the central mechanism for the control claim, but it is asserted with little comparative evidence. It does not show how constraints would be specified for open-ended tasks or how learned components are inspected.
• Specialized systems can be small: a DeepMind world-model agent learned to find diamonds in Minecraft from scratch on one GPU per agent, and top chess engines run on a laptop. (Moderate) — It addresses per-use running cost for narrow tasks but not like-for-like comparison with language-model agents, nor development and training cost.
• Modular systems are harder to build because each must be engineered for its problem, which gives frontier labs a commercial reason to prefer one large model that serves many uses. (Moderate) — It establishes a plausible incentive but not that the incentive outweighs technical reasons. It also introduces a build cost that complicates the 'lower cost' conclusion.

View this argument on LogicFirst.ai