Claude Code architecture analysis: reverse-engineering the TypeScript source reveals 5 core values and 13 design principles of an AI agent tool

What does this paper do?

A team of researchers (Jiacheng Liu, Xiaohan Zhao, Xinyi Shang, Zhiqiang Shen) published an extensive analysis of Claude Code’s architecture on arXiv on April 17, 2026 — Anthropic’s AI coding agent that has become one of the most influential tools in its category over the past year.

The approach is uncommon: the authors reverse-engineered the TypeScript source code of the distributed Claude Code package (shipped as an npm module that is technically readable), mapped the architecture, and compared it with OpenClaw — an open-source agent that attempts to replicate Claude Code functionality.

The goal was not “copy Claude Code,” but rather: understand the design principles Anthropic implicitly follows, so the broader community can build better agents.

What they found — 5 core values

The analysis distilled 5 values that structurally guide Claude Code’s architecture:

1. Human authority — the user always has the final word. The agent can suggest, plan, execute — but critical decisions (destructive actions, committing, deploying) pass through explicit approval.

2. Safety — multi-layered defense: runtime permissions, sandboxing, audit log, rollback. The agent cannot “accidentally” destroy a project.

3. Execution — the agent does not just talk about a solution, it executes it. Shell access, file edits, git operations — all from the same context.

4. Capability — a broad tool set (bash, read, edit, grep, web fetch, etc.) makes the agent practical for real work, not just demos.

5. Adaptability — the skills mechanism enables extension without recompilation. MCP server support opens integration with external systems.

The authors then derive 13 design principles that operationalize these 5 values — e.g., “every destructive tool requires explicit approval,” “context retains no more than N messages for token efficiency,” “tool results go back into the model as the next input without mixing roles.”

The surprise: the core is a simple while loop

The most interesting finding in the paper is just how simple the core of Claude Code actually is:

while not done:
    response = model(current_context)
    if response contains tool_call:
        result = execute_tool(tool_call)
        context.append(result)
    else:
        wait_for_user_input()

All complexity — intelligence, context, tools, safety — lives in:

• The prompt and system message (how the model is instructed)
• The tool set and their permissions (what the agent may do, and under what conditions)
• Context management (what is retained, compressed, deleted)

There is no magical “agent orchestration” library at the core. Just the loop, the model, and carefully designed tools.

Why does this matter for everyone building agents?

The conclusion is significant:

• You don’t need complex frameworks. LangGraph, CrewAI, AutoGen, AGP — all offer rich orchestration, but Claude Code shows that powerful simplicity is competitive.
• Values over features. The 5 core values Anthropic follows are visible in every aspect of the product — from UX to security thresholds.
• The OpenClaw replica confirms it: it is possible to build a competitive agent with a simple architecture if values and tools are well defined.

The paper is a preprint. Code is available (the paper mentions reproducibility), and the analysis is concrete enough to serve as a blueprint for your own agent projects. For engineers thinking about building vs. buying in the AI agent space — this is a required reference point.