The Cartesian Cut in Agentic AI
A new framework argues that where control lives in AI agent systems — inside the model or outside it — determines whether they are robust or brittle.
The Thesis
Most AI agents today are built by bolting a large language model (LLM) to an external 'runtime' — a layer of code that handles memory, tools, and decision logic on the model's behalf. This paper calls that architecture 'Cartesian agency,' borrowing from Descartes' mind-body split: the model thinks, the runtime acts, and the two communicate through a narrow symbolic interface (structured text or function calls). The authors argue this split has real engineering advantages — it is easier to build, audit, and govern — but it also creates fragility, because the interface between model and runtime becomes a bottleneck and a single point of failure. They contrast this with how biological brains work: prediction and control are deeply intertwined across many feedback layers, not separated by a clean symbolic handshake. The paper proposes a spectrum of architectures — from 'bounded services' (LLMs as pure tools) to 'integrated agents' (where the model handles more control internally) — and argues that choosing wisely among them is the central design question for practical AI systems.
Catalyst
LLM-based agents have moved from research curiosity to production deployment in the past 18 months, with frameworks like LangChain, AutoGPT, and Anthropic's tool-use APIs shipping at scale. As those systems hit real-world reliability problems — hallucinated tool calls, cascading failures, unpredictable multi-step behavior — there is now empirical pressure to understand why they fail, not just how to patch them. This paper arrives as the field is actively debating architectural choices rather than assuming one template fits all tasks.
What's New
Earlier agent frameworks (ReAct, Toolformer, early AutoGPT-style systems) treated the LLM-plus-runtime pattern as a pragmatic default and focused on improving individual components — better prompts, more tools, longer context. This paper steps back and provides a theoretical lens: it maps the LLM-agent architecture onto the classical 'Cartesian cut' in philosophy of mind and cognitive science, where mind and body are treated as categorically separate. By naming and analyzing the cut explicitly, the authors make legible a design dimension that was previously implicit, and they sketch what it would mean to move the cut — giving the model more or less control over its own state and policies.
The Counter
This paper is entirely theoretical — it presents no experiments, no benchmarks, and no empirical comparisons between the architectural approaches it describes. The 'Cartesian cut' framing is intellectually interesting, but renaming a known pattern does not solve it. Practitioners already know that putting logic outside the model creates bottlenecks; they do it anyway because it is the only reliable way to maintain auditability and control in production systems. The biological brain analogy is evocative but not actionable: we cannot simply import cortical feedback loops into transformer architectures. The paper also does not grapple seriously with the governance problem it briefly acknowledges — 'integrated agents' that handle more control internally are precisely harder to audit, align, and debug. Without a concrete implementation or failure analysis, this remains a taxonomy exercise dressed in neuroscience language, and the field may simply move on empirically without needing the framework.
Longs
- PLTR — builds agentic AI systems for defense and government where robustness and oversight tradeoffs are critical
- MSFT — Azure AI and Copilot Studio are large-scale deployments of exactly the Cartesian agent architecture this paper analyzes
- AI (C3.ai) — enterprise agent platforms directly exposed to architectural reliability debates
- BOTZ (Global X Robotics & AI ETF) — broad exposure to agentic AI infrastructure buildout
Shorts
- Vendors selling 'prompt-and-orchestrate' agent platforms who assume the current LLM-plus-runtime split is permanent — this paper argues that split is a design choice with known failure modes, not an architectural inevitability
- Enterprise software companies building rigid workflow automation on top of LLMs without considering control-layer brittleness — they face reliability risk as tasks grow more complex
Enablers (Picks & Shovels)
- LangGraph and LangChain — open-source runtime infrastructure for the 'external control state' the paper describes
- Anthropic's tool-use and Model Context Protocol (MCP) — the symbolic interface layer the paper critiques
- OpenAI's Assistants API — another concrete instantiation of the Cartesian agent pattern
- Neuroscience datasets and computational neuroscience models — the paper draws on brain-as-controller literature to motivate integrated alternatives
Private Watchlist
- LangChain — dominant open-source agentic framework, directly building the runtime layer this paper theorizes
- Cognition AI (Devin) — building integrated software engineering agents where the control boundary question is acute
- Adept AI — focused on action-oriented agents; architecture choices match the paper's spectrum
- Letta (formerly MemGPT) — working on stateful agent memory, a core concern of the Cartesian cut problem
Resources
The Paper
LLMs gain competence by predicting words in human text, which often reflects how people perform tasks. Consequently, coupling an LLM to an engineered runtime turns prediction into control: outputs trigger interventions that enact goal-oriented behavior. We argue that a central design lever is where control resides in these systems. Brains embed prediction within layered feedback controllers calibrated by the consequences of action. By contrast, LLM agents implement Cartesian agency: a learned core coupled to an engineered runtime via a symbolic interface that externalizes control state and policies. The split enables bootstrapping, modularity, and governance, but can induce sensitivity and bottlenecks. We outline bounded services, Cartesian agents, and integrated agents as contrasting approaches to control that trade off autonomy, robustness, and oversight.