Claude Code Architecture Deep Dive: Why a Single-Loop Design Beats Multi-Agent Systems

Article

Claude Code has become the hottest tool in AI-assisted programming. A senior Google engineer claimed it produced in one hour what his team spent a year building. Former Tesla AI Director Andrej Karpathy said he'd "never felt so behind." And Boris, the creator of Claude Code, revealed that every contribution he made to the codebase over 30 days — 40,000 lines of new code across 259 PRs — was 100% written by Claude Code.

Just six months after launch, the tool has surpassed $1 billion in annualized revenue. Yet when the Metis X team intercepted and analyzed every network request it made, their conclusion was surprising: its power comes precisely from what it doesn't do.

Counterintuitive: A Single-Loop Architecture Beats Multi-Agent

While the rest of the AI world races to build multi-agent orchestration, complex RAG pipelines, and nested agents, Claude Code follows one internal rule — Keep It Simple.

This reflects the core argument of the classic AI essay The Bitter Lesson, published in 2019 by reinforcement learning pioneer and Turing Award winner Rich Sutton. After reviewing 70 years of AI research history, Sutton concluded that whenever researchers tried to hard-code human domain knowledge into AI systems, it might work in the short term but would inevitably be surpassed by approaches using "more compute + simpler algorithms." Chess, Go, speech recognition, computer vision — no exceptions. The essay has been widely cited in the era of large language models because it accurately predicted the rise of the GPT series: not through carefully engineered linguistic rules, but through the Transformer architecture combined with massive data and compute. History has repeatedly shown that general-purpose compute and simple methods ultimately beat elaborate human-designed systems.

Multi-agent architecture became a popular paradigm for AI application development in 2023–2024, with representative frameworks including AutoGen, CrewAI, and LangGraph. The core idea is to decompose complex tasks and distribute them across multiple specialized agents running in parallel. In practice, however, serious problems emerged: context loss in inter-agent communication, cascading error amplification across the pipeline, and near-impossible-to-debug "black box" behavior. As models like Claude 3.5 and GPT-4o expanded their context windows to over 200,000 tokens, a single model's ability to handle complex tasks improved dramatically — further undermining the case for multi-agent setups.

Claude Code runs a single control loop: if the model returns a tool call, execute the tool; if it returns text, end the conversation. The conversation history is flat, and sub-tasks are allowed at most one level of branching. For example, if writing a Python script reveals the need to install a dependency via pip first, the main thread spawns a sub-agent to handle the installation, then writes the result back to the main thread and continues — but a sub-agent is never allowed to spawn another sub-agent.

Why design it this way? A Reddit user put it bluntly: every additional layer of abstraction makes debugging ten times harder. When you have five or more agents passing outputs from A to B to C to D, a single failure requires tracing the entire chain to find the root cause — a massive effort that may not even succeed. With a single-loop architecture, all decision-making stays in one primary model. Tool call results are written directly back into the same context window, the state is always visible and traceable, and you can quickly pinpoint the source of a bug by following a single thread.

Prompt Engineering: Why a 9,400-Token Tool Description Matters

A set of key figures reveals Claude Code's design philosophy:

• System Prompt: only 2,800 tokens
• Tool Prompt: a full 9,400 tokens
• Collaborative memory file (claude.md): 1,000–2,000 tokens

This means the effort goes into teaching the model how to use tools, not into defining "who it is."

claude.md is a collaborative memory file that records project-specific rules: which directories to ignore, which libraries to use (e.g., NumPy, Pandas), what the test commands are, code style conventions, and so on. Understanding this design requires first appreciating the memory limitations of large language models — models are fundamentally stateless. Every API call starts from scratch with no native cross-session memory. The engineering community has developed several solutions: vector databases for storing historical summaries, structured databases for recording user preferences, and the simplest approach of all — "memory file injection." claude.md uses exactly this last approach. Its design philosophy echoes the software engineering principle of "Convention over Configuration." It's not a one-time prompt but a file that is continuously modified and updated throughout development, forcibly injected into every request to achieve long-term memory. The effectiveness of this approach depends heavily on the model's ability to understand long contexts — which is why it only became truly mature and usable after the Claude 3 series launched.

The prompts also use XML for structured markup, including good_example and bad_example tags to guide model behavior, and system_reminder tags to surface details the model tends to forget. As one engineer put it: "The model is like the smartest intern you've ever had — you need to write the rules into its DNA, or it will still make mistakes."