Dive into Claude Code: The Design Space of Today’s and Future AI Agent Systems

Paper: arXiv:2604.14228 Code: VILA-Lab/Dive-into-Claude-Code Code reference: main @ 52481905 (2026-05-25)

1. Motivation (研究动机)

当前方法的问题

AI coding assistant 已经从 GitHub Copilot 式 autocomplete、Cursor/Windsurf 式 IDE chat，走向能自主规划、执行 shell、读写文件、调用外部服务并持续迭代的 agentic coding system。论文指出，这种从“给建议”到“代表用户行动”的转变带来了一组 completion-based 工具没有的架构问题：谁来决定下一步、工具调用如何授权、上下文如何压缩、扩展机制如何进入 agent loop、子代理如何隔离、session 如何恢复以及旧权限是否应该跨 session 延续。

Claude Code 的公开材料主要是用户文档，而不是源码级架构说明；但它已经是一个真实生产系统。论文引用 Anthropic 对 132 名工程师和研究人员的内部调查：约 $27\%$ 的 Claude Code-assisted tasks 是“如果没有工具就不会尝试”的工作。这说明系统不是只把现有任务做快，而是在改变用户愿意承担的任务边界，因此需要从 source-level 解释它为什么能支撑这种工作流。

本文要解决的问题

本文不是提出一个新模型或新 benchmark，而是回答一个系统设计问题：一个现代 Code & SWE Agent 如何把 LLM、工具、权限、记忆、扩展和 session persistence 组合成可用的生产级 harness。作者以 Claude Code 为主要样本，用源码分析抽取出五类 human values、十三条 design principles、七组件高层结构、五层（5 layers）subsystem architecture，并把这些设计选择与 OpenClaw 这样的独立开源 agent system 对照。

为什么值得研究

如果只看模型能力，容易误以为 agent 系统的核心是更强的 planner 或更长的 chain-of-thought。论文的价值在于把注意力转向 harness：权限门控、context management、tool routing、recovery、append-only persistence、subagent isolation 这些“非智能”基础设施，才是 agent 能长期、可控、可恢复地执行工作的关键。对未来系统来说，这篇论文提供的是一张 design-space map：哪些问题是所有 coding agent 都必须回答的，哪些答案取决于部署场景、trust boundary 和用户关系。

2. Idea (核心思想)

核心洞察是：Claude Code 的“智能”并不主要来自复杂 planner，而来自“model judgment inside a deterministic operational harness”。论文估计 Claude Code 代码库中只有约 $1.6\%$ 是 AI decision logic，剩余 $98.4\%$ 是权限、工具路由、上下文、恢复、持久化等确定性基础设施；agent loop 本身只是一个简单 while-loop，复杂度集中在 loop 周围。

本文的关键创新是把 Claude Code 分解为一组可复用的设计问题，而不是把它描述成单个产品功能：reasoning 放在模型还是 harness、默认 safety posture 是 deny-first 还是 sandbox-first、扩展接口是单一 tool API 还是多机制栈、context 是直接截断还是渐进压缩、subagent 是共享上下文还是隔离 sidechain、session 恢复时权限是否一并恢复。作者再用 OpenClaw 校准这些问题，说明相同问题在不同 deployment topology 下会得到不同答案。

它与 LangGraph/AutoGen/Devin/SWE-Agent/OpenHands 等思路的根本差异在于：Claude Code 不把核心控制流编码成显式 graph 或 planner，也不主要依赖 container sandbox 兜底，而是让模型在一个统一 queryLoop 中自由选择动作，同时用 deny-first permission、hook lifecycle、context shapers、append-only transcript 和 subagent isolation 来约束外部副作用。OpenClaw 则把 agent loop 放进持久 WebSocket gateway 的 control plane 中，trust boundary 从“模型与本机执行环境之间”移到“gateway perimeter”。

3. Method (方法)

3.1 Evidence base：源码级设计空间分析

论文的方法论是 source-level architecture analysis，不是训练或评测新模型。证据分三层：Tier A 是 Anthropic 官方文档和工程文章，能说明产品意图；Tier B 是对 publicly available npm package extraction 得到的 Claude Code TypeScript codebase v2.1.88 的文件/函数级分析，是最强证据；Tier C 是社区分析、OpenClaw 结构对照或代码模式推断，需要保留不确定性。作者称源代码语料约 1,884 个文件、约 512K 行 TypeScript；OpenClaw 被用作 calibration，而不是 ground truth。

3.2 Overall framework：七组件 agent system

Figure 1 解读：这张图把 Claude Code 抽象为七个功能组件：User、Interfaces、Agent Loop、Permission System、Tools、State & Persistence、Execution Environment。所有入口面（interactive CLI、headless CLI、Agent SDK、IDE/Desktop/Browser）最终汇入同一个 agent loop；模型只产生 tool_use 或文本，真正的文件系统、shell、web/MCP 访问都由 harness 解析、授权、执行并把结果写回上下文。

Figure 3 解读：七组件模型进一步展开为五层：Surface layer 负责 entrypoints 和 terminal UI；Core layer 包含 queryLoop 与 compaction pipeline；Safety/Action layer 包含 permissions、hooks、tools、MCP、sandbox、subagent spawning；State layer 包含 context assembly、runtime state、JSONL persistence、CLAUDE.md/memory、sidechain transcripts；Backend layer 连接 execution backends 和外部资源。这个分层说明 Claude Code 的产品复杂度主要是 OS-like harness，而不是单一 planner。

设计直觉

直觉上，Claude Code 把“判断下一步做什么”留给模型，把“行动能不能发生、发生后如何记录、失败后如何恢复”留给确定性系统。这样做的好处是模型升级时 harness 不需要重写控制图；坏处是系统正确性依赖多个基础设施层同时工作，例如权限规则、hook、sandbox、context shaper 和 transcript loader 之间的交互会变得难以完全预测。

3.3 Agentic query loop：一个简单 while-loop 加复杂 operational harness

Figure 2 解读：一个 turn 从用户 prompt 进入 context assembly，模型被调用后可能输出文本或 tool_use。如果有工具请求，先通过 permission gate，再 dispatch 到工具执行；tool result 进入 conversation，loop 再次调用模型。上下文压力由 compaction 管理；当模型只输出文本、达到 max turns、prompt too long、hook 阻止继续或 abort signal 触发时，turn 结束。

queryLoop 的关键步骤包括 settings resolution、初始化单个 State 对象、用 getMessagesAfterCompactBoundary 从 compact boundary 后取消息、执行五个 pre-model context shapers、streaming deps.callModel()、dispatch tool_use、permission gate、收集 tool_result、判断 stop condition。它是一个 AsyncGenerator，向 UI 层 yield StreamEvent、RequestStartEvent、Message、TombstoneMessage 和 ToolUseSummaryMessage，所以 UI 能流式显示而核心控制流仍保持单一 loop。

def query_loop(state, deps, permission_callback, max_turns):
    turns = 0
    while turns < max_turns and not state.abort_signal.triggered:
        messages = get_messages_after_compact_boundary(state.transcript)
        messages = apply_tool_result_budget(messages)
        messages = snip_if_needed(messages, state.flags)
        messages = microcompact(messages, state.cache_info)
        messages = apply_context_collapse(messages, state.collapse_store)
        messages = auto_compact_if_still_over_budget(messages, deps.model)
 
        response_stream = deps.call_model(
            system_prompt=state.system_prompt,
            user_context=state.user_context,
            messages=messages,
            tools=state.available_tools,
            model=state.model,
        )
        response = collect_stream(response_stream)
        if response.is_text_only():
            if run_stop_hooks(response):
                state.append(response)
                return response
            continue
 
        for tool_call in response.tool_uses:
            decision = can_use_tool(tool_call, state.permission_context, permission_callback)
            if not decision.allowed:
                state.append_permission_denial(tool_call, decision.reason)
                continue
            result = execute_tool_streaming_or_serial(tool_call, state.tool_context)
            state.append_tool_result(tool_call, result)
        turns += 1
    return state.final_message_or_stop_reason()

3.4 Permission and control boundary：deny-first、ask-by-default、可编程 hooks

Figure 4 解读：permission gate 的核心不是简单 allowlist，而是三种机制组合：declarative permission rules、global trust modes、programmable hooks。Progressive Trust 让用户从低自治逐步提高到高自治；Deny-First, Ask-by-Default 确保 deny 规则总是优先于 allow，未知动作默认问用户；Composable Policy 让 rules、modes、hooks 能独立配置。

权限模式跨 type definition 共有七类：外部可见的 plan、default、acceptEdits、dontAsk、bypassPermissions；feature-gated 的 auto；内部用于 subagent escalation 的 bubble。规则评估在 permissions.ts 中 deny-first：toolMatchesRule 先查 deny，广义 deny 不能被狭义 allow 覆盖。acceptEdits 会自动批准 working directory 内编辑和部分 filesystem shell 命令（mkdir/rmdir/touch/rm/mv/cp/sed），其他 shell 命令仍需批准；bypassPermissions 跳过大多数 prompt，但 bypass-immune safety checks 仍存在。

完整 authorization pipeline 有几个阶段：filterToolsByDenyRules 先在 tool pool assembly 时把 blanket-denied 工具从模型视野中移除；PreToolUse hook 可以 deny/ask 或 rewrite input，但 hook allow 不绕过后续 deny；rule engine 对普通工具和 mcp__server__tool 形式的 MCP tool 做匹配；permission handler 根据 coordinator、swarm worker、speculative classifier、interactive 四种 runtime context 分支处理。auto 模式由 yoloClassifier.ts 参与，读取 base system prompt、external permissions template，以及 internal-user template；classifier 对 transcript 和 permission template 下的 tool invocation 产出 allow、deny 或 manual approval。

def authorize_tool_call(tool_call, rules, mode, hooks, classifier, sandbox):
    if tool_is_pre_filtered_by_deny_rules(tool_call, rules):
        return Decision(False, "tool hidden by deny rule")
 
    hook_decision, rewritten = run_pre_tool_use_hooks(tool_call, hooks)
    tool_call = rewritten or tool_call
    if hook_decision in {"deny", "ask"}:
        return decision_from_hook(hook_decision)
 
    if matches_deny_rule_first(tool_call, rules):
        return Decision(False, "deny rule matched")
    if matches_allow_rule(tool_call, rules) or fast_path_allowed_by_mode(tool_call, mode):
        return maybe_sandbox(tool_call, sandbox)
 
    if mode == "auto":
        cls = classifier.evaluate(transcript=tool_call.context, request=tool_call)
        if cls in {"allow", "deny"}:
            return Decision(cls == "allow", f"classifier={cls}")
 
    if mode in {"dontAsk", "bypassPermissions"}:
        return maybe_sandbox(tool_call, sandbox)
    return ask_user_interactively(tool_call)

论文也强调 defense-in-depth 的独立性假设会被性能约束破坏：安全研究指出超过 50 个 subcommands 的命令会退化成一个 generic approval prompt，而不是逐个 subcommand 运行 deny-rule checks，因为逐项解析导致 UI freeze。这说明多层安全如果共享同一性能瓶颈，就不是完全独立的防线。

3.5 Extensibility：MCP、Plugins、Skills、Hooks 四机制栈

Figure 5 解读：这张图把 agent loop 拆成三个插入点：assemble() 决定模型看见什么，model() 决定模型能调用哪些工具，execute() 决定工具调用如何被 gate、rewrite、annotate。MCP servers 主要扩展 flat tool pool，skills 通过低成本描述让模型调用 SkillTool 注入领域指令，hooks 在 lifecycle 上阻断/改写/补充上下文，plugins 则把多个机制打包分发。Figure 5 未以独立图片出现在 arXiv source extract 中；这里使用 official GitHub repo 的 assets/extensibility.png。

Mechanism	Unique capability	Context cost	Insertion point
MCP servers	External service integration，多 transport	High（tool schemas）	model(): tool pool
Plugins	Multi-component packaging + distribution	Medium（varies）	all three points
Skills	Domain-specific instructions + meta-tool invocation	Low（descriptions only）	assemble(): context injection
Hooks	Lifecycle interception + event-driven automation	Zero by default	execute(): pre/post tool

def assemble_turn_surface(base_tools, mcp_servers, plugins, skills, hooks, rules):
    context = []
    context += load_claude_md_hierarchy()
    context += [skill.frontmatter_description for skill in skills]
    context += collect_mcp_resources_and_prompts(mcp_servers)
    context += run_session_start_hooks(hooks)
 
    tool_pool = list(base_tools)
    tool_pool += [server.tool_schema for server in mcp_servers]
    tool_pool += plugin_contributed_tools(plugins)
    tool_pool += [SkillTool(skills), AgentTool()]
    tool_pool = filter_tools_by_deny_rules(tool_pool, rules)
 
    lifecycle = HookPipeline(pre_tool=hooks.pre_tool, post_tool=hooks.post_tool)
    return context, tool_pool, lifecycle

3.6 Context construction and memory：透明文件记忆 + 五层渐进压缩

Figure 6 解读：context window 的来源不仅是 conversation history，还包括 system prompt、output styles、environment info、CLAUDE.md hierarchy、auto memory、path-scoped rules、MCP tool names、deferred tool definitions、file reads、command outputs、subagent summaries 和 compact summaries。重要的是，很多来源会 late injection：relevant-memory prefetch、MCP instructions deltas、agent listing deltas、background agent notifications 可能在 turn 内增加上下文。

CLAUDE.md 被设计成可读、可编辑、可 version-control 的 Markdown，而不是 opaque vector DB。四层 memory 类型包括 managed memory（如 Linux 的 /etc/claude-code/CLAUDE.md）、user memory（~/.claude/CLAUDE.md）、project memory（CLAUDE.md、.claude/CLAUDE.md、.claude/rules/*.md）和 local memory（CLAUDE.local.md）。文件从当前目录向 root 搜索；更靠近当前目录的文件后加载，因而获得更高 attention。它也支持 @include 模块化指令，并用 processed paths 防止循环引用。

与 deterministic permission 不同，CLAUDE.md 作为 user context 而不是 system prompt 进入 API request，所以遵循它是 probabilistic guidance，不是强制 enforcement。论文把这解释为 guidance/enforcement separation：CLAUDE.md 和 memory 给模型行为倾向，deny-first permission rules 提供确定性边界。

五层 compaction pipeline 体现 lazy degradation：先用轻量、局部、低破坏的策略，不够再升级到更强压缩。顺序是 budget reduction（always active，对 tool result 做 per-message size limit）、snip（HISTORY_SNIP，修剪较旧 history）、microcompact（CACHED_MICROCOMPACT，cache-aware 细粒度压缩）、context collapse（CONTEXT_COLLAPSE，read-time projection，不改 REPL array）、auto-compact（默认启用，可禁用，调用模型生成 summary）。

def shape_context_before_model_call(messages, flags, transcript, model):
    messages = apply_tool_result_budget(messages)
    if flags.HISTORY_SNIP:
        messages, tokens_freed, boundary = snip_old_history(messages)
        transcript.append(boundary)
    messages, compaction_info = microcompact(messages, cache_aware=flags.CACHED_MICROCOMPACT)
    if flags.CONTEXT_COLLAPSE:
        messages = apply_read_time_collapse_projection(messages)
    if still_over_pressure_threshold(messages):
        summary = model(get_compact_prompt(messages))
        messages = build_post_compact_messages(
            boundary_marker=True,
            summary_messages=summary,
            messages_to_keep=select_recent_and_anchored(messages),
        )
    return messages

3.7 Subagent delegation：隔离上下文而不是共享 transcript

Figure 7 解读：AgentTool 可以 dispatch 到 built-in subagents（Explore、Plan、general-purpose 等）或 custom subagents；每个 subagent 有独立上下文、重建的 permission context、独立 tool set 和 sidechain transcript。图中三个轴很关键：routing（teammate）、isolation（worktree/remote/in-process）、lifecycle（async/sync）。

内置 subagent 最多六类，取决于 feature flags 和 entrypoint：Explore 以读/搜为主并 deny write/edit；Plan 生成结构化计划；General-purpose 更通用；Claude Code Guide 用于 onboarding/documentation；Verification 跑 tests/lint；Statusline-setup 专门配置 terminal status line。用户也可以通过 .claude/agents/*.md 定义 custom agent，frontmatter 包含 description、tools、disallowedTools、model、effort、permissionMode、mcpServers、hooks、maxTurns、skills、memory scope、background、isolation 等字段。

def run_subagent(parent_state, agent_spec, prompt):
    child_context = build_isolated_context(
        system_prompt=agent_spec.body_or_prompt,
        tools=resolve_allowed_tools(agent_spec, parent_state.sdk_permissions),
        memory_scope=agent_spec.memory,
        mcp_servers=agent_spec.mcpServers,
    )
    permission_context = rebuild_permission_context(
        parent_mode=parent_state.permission_mode,
        override=agent_spec.permissionMode,
        bubble_to_parent=agent_spec.can_show_permission_prompts,
    )
    workspace = maybe_create_worktree(agent_spec.isolation, parent_state.repo)
    sidechain = open_sidechain_transcript(agent_spec.name)
    result = query_loop(State(prompt, child_context, permission_context, workspace), deps=parent_state.deps)
    sidechain.write(result.full_history)
    return result.final_text, result.metadata

这种 summary-only return 是 context-conservation 的核心：父 agent 只接收子 agent 最终文本和 metadata，不接收完整子会话历史；每个 subagent 的 .jsonl 和 .meta.json sidechain 可供审计。论文引用 Claude Code agent teams 在 plan mode 中约消耗标准 session 的 $7\times$ tokens，说明如果完整共享多代理历史，context blow-up 会非常快。

3.8 Session persistence：append-only transcript 与“不恢复权限”

Figure 8 解读：图把 live session state（context window、compaction）和 durable storage（session transcripts、history.jsonl、subagent sidechains、checkpoints）分开。Transcript 记录完整会话和 compaction markers；live context 可以被压缩，session 的有用寿命不被模型 context window 限死。关键安全设计是：resume/fork 恢复消息，但不恢复 session-scoped permissions。

session transcript 是 project-specific path 下的 mostly append-only JSONL；getTranscriptPath 由 sessionProjectDir 和 sessionId 决定。三个 persistence channels 分别是 per-session transcript、全局 prompt history（history.jsonl，支持 Up-arrow/ctrl+r）和 subagent sidechains。Transcript 还记录 compaction markers、file-history snapshots、attribution snapshots、content-replacement records。--resume 通过 conversationRecovery.ts replay transcript；fork 通过 commands/branch/branch.ts 从旧 session 创建新 session，但旧 session 的权限不序列化、不自动恢复。

这种选择牺牲便利性换取安全不变量：permission grant 只在当前 trust domain 内有效。compact_boundary 也被设计成 append-friendly：annotateBoundaryWithPreservedSegment 记录 headUuid、anchorUuid、tailUuid，loader 读时修补 message chain，而不是改写已经写入的 transcript lines。

3.9 Package structure appendix：运行时职责与条件工具

Figure 9 解读：附录把 TypeScript source directories 和关键文件映射到 runtime responsibilities。main.tsx 约 804KB，负责 entry point、mode dispatch、setup；query.ts 约 68KB，负责 core agent loop 和五个 context shapers；QueryEngine.ts 约 47KB，负责 SDK/headless conversation wrapper；Tool.ts 约 30KB，定义 tool interface/types/utilities；还有 mcp/client.ts、compact.ts、AgentTool.tsx、runAgent.ts 等大文件分别承担 MCP、compaction、subagent dispatch 和 21-parameter agent lifecycle。

论文还列出 conditional tools：always included 包括 AgentTool、BashTool、FileReadTool、FileEditTool、FileWriteTool、SkillTool、WebFetchTool、WebSearchTool；environment-dependent 包括 GlobTool/GrepTool、ConfigTool、PowerShellTool；feature-flagged 包括 TaskCreate/Get/Update/List、EnterWorktreeTool、TeamTools、ToolSearchTool；null-checked 包括 SuggestBackgroundPRTool、WebBrowserTool、RemoteTriggerTool、MonitorTool、SleepTool。

3.10 公式、训练目标与 released-code 差异

本文没有训练目标、loss function 或模型优化公式；它的“objective”是设计空间解释和系统结构归纳。唯一显式进入实验讨论的概率式指标是相关工作中的 $pas{s}^k$，用于衡量 $k$ 次独立 agent trials 全部成功的概率；但这不是本文提出的评价指标。论文未报告 GPU、learning rate、batch size 或训练 steps。

论文公式与 released code 实现差异：official GitHub VILA-Lab/Dive-into-Claude-Code 在 main@52481905 发布的是 companion paper/docs/assets repo，released repo 不包含被分析的 Claude Code v2.1.88 source；也不包含作者分析的 Claude Code v2.1.88 TypeScript source extraction 本体。因此，本笔记中的 pseudocode 依据论文和 companion docs 中列出的 source file/function names（如 query.ts、permissions.ts、compact.ts、AgentTool.tsx）重构流程，不声称能在 released repo 中直接运行；released repo 可验证的是论文、README、architecture docs 和 figure assets。

Code reference: main @ 52481905 (2026-05-25) — pseudocode and mapping based on this companion repo plus paper-cited Claude Code source names

Paper Concept	Source File	Key Class/Function
Companion overview and design guide	README.md, docs/build-your-own-agent.md	paper summary, design decisions, cross-system comparison
Architecture deep dive	docs/architecture.md	5-layer subsystem decomposition, safety layers, context pipeline summary
Paper PDF and assets	paper/Dive_into_Claude_Code.pdf, assets/*.png	official PDF and rendered figures, including Figure 5 fallback asset
Unified agent loop	paper-cited query.ts	queryLoop, getMessagesAfterCompactBoundary, context shaper sequence
Headless/SDK wrapper	paper-cited QueryEngine.ts	QueryEngine conversation wrapper
Tool interface and pool	paper-cited Tool.ts, tools.ts	assembleToolPool, filterToolsByDenyRules, tool schema handling
Permission system	paper-cited permissions.ts, types/permissions.ts, useCanUseTool.tsx	toolMatchesRule, permission modes, permission handler branches
Auto-mode classifier	paper-cited yoloClassifier.ts	transcript classifier, external/internal permission templates
Hook lifecycle	paper-cited coreTypes.ts, types/hooks.ts	27 hook events, 5 permission-related hook outputs
Context and memory	paper-cited context.ts, claudemd.ts, compact.ts	getSystemContext, getUserContext, processMemoryFile, compactConversation
Subagent orchestration	paper-cited AgentTool.tsx, runAgent.ts, loadAgentsDir.ts, loadPluginAgents.ts	Agent tool schema, permission override, sidechain transcript, custom agent loading
Session persistence	paper-cited sessionStorage.ts, conversationRecovery.ts, commands/branch/branch.ts, history.ts	transcript path, resume replay, fork, global prompt history

4. Experimental Setup (实验设置)

数据与规模

本文的“数据集”是系统分析语料，而不是 supervised/RL 训练集。核心语料包括 Claude Code v2.1.88 的 publicly available npm package extraction，约 1,884 个 TypeScript 文件、约 512K 行代码；Anthropic 官方文档、creator statements 和工程文章；公开安全研究与社区分析；以及用于对照校准的 OpenClaw snapshot。companion GitHub repo 在 main@52481905 提供 README、架构文档、PDF 和 figure assets，但不提供被分析的 Claude Code source extraction。

Baselines / compared systems

主要对照对象是 OpenClaw，比较维度包括 system scope、trust model、agent runtime、extension architecture、memory/context、multi-agent/routing。论文还把 Claude Code 放进 AI coding tool taxonomy：inline completion（Copilot、Tabnine）、chat-integrated（Cursor、Windsurf、Cody）、agentic CLI（Claude Code、Codex CLI、Aider）、fully autonomous（Devin、SWE-Agent、OpenHands）。在具体设计点上还对比 LangGraph/graph routing、AutoGen/conversation framework、SWE-Agent/OpenHands 的 container isolation、Aider 的 git rollback。

Evaluation metrics / analysis dimensions

本文没有标准 benchmark metric；评价方式是设计空间维度和证据强度。核心维度包括五个 values（Human Decision Authority、Safety/Security/Privacy、Reliable Execution、Capability Amplification、Contextual Adaptability）、十三个 design principles、七组件/五层架构、六个 Claude Code vs OpenClaw comparison dimensions、以及 long-term human capability preservation 这个 evaluative lens。证据强度用 Tier A/B/C 区分。

Training config / hardware / hyperparameters

论文未训练新模型，也未报告 GPU、训练步数、learning rate、batch size 或 optimizer。所有“配置数字”来自源码/文档分析而非 training launch script：例如 54 个 built-in tools（19 unconditional、35 conditional）、27 个 hook events、最多七种 permission modes、五层 compaction pipeline、四种 extension mechanisms。对于 agentic 系统复现，作者更关心 feature flags、permission modes、context shaper 顺序、transcript format 和 extension insertion points，而不是 ML training hyperparameters。

5. Experimental Results (实验结果)

主结果：Claude Code 的设计点

论文的主要结论是，Claude Code 是“简单 reactive loop + 厚 operational harness”的设计点。定量上，作者估计 decision logic 只占约 $1.6\%$，operational harness 占 $98.4\%$；结构上，系统有七个高层组件、五层 subsystem、最多 54 个内置工具（19 unconditional、35 conditional）、27 个 hook events（其中 5 个直接参与 permission flow）、最多七个 permission modes、五个 context shapers、四个 extension mechanisms。

Claude Code vs OpenClaw：六维对照

Dimension	Claude Code	OpenClaw
System scope	CLI/IDE coding harness，ephemeral per-session process	persistent WebSocket gateway daemon，多 channel control plane
Trust model	per-action deny-first rules + hooks + optional ML classifier，7 permission modes	single trusted operator per gateway，DM pairing、allowlists、gateway auth，opt-in sandboxing
Agent runtime	queryLoop async generator 是系统中心	Pi-agent runner 嵌入 gateway RPC dispatch，per-session queue serialization
Extension architecture	MCP、plugins、skills、hooks 四机制，context cost 分层	manifest-first plugin system，12 capability types，central registry，built-in MCP
Memory/context	CLAUDE.md 4-level hierarchy，5-layer compaction，LLM-based memory scan	workspace bootstrap files、separate MEMORY/daily notes、provider-pluggable auto-compaction、optional hybrid search
Multi-agent/routing	task-delegating subagents、worktree isolation、final response returned to parent	routing 与 sub-agent delegation 分离，支持 isolated agents、distinct workspaces、max nesting depth 5（default 1，recommended 2）

这个对照说明：两者回答的是同一类设计问题，但部署拓扑不同导致答案相反。Claude Code 把 trust boundary 放在 model 与 execution environment 之间；OpenClaw 把 trust boundary 放在 gateway perimeter。Claude Code 把 agent loop 当中心；OpenClaw 把 gateway control plane 当中心，agent loop 是其中组件。二者也不是互斥关系：OpenClaw 可以通过 ACP 承载 Claude Code、Codex CLI、Gemini CLI 等外部 coding harness。

Ablation-style findings / value tensions

论文没有传统 ablation table，但用 value tensions 抽象出系统层“消融如果拿掉某层会怎样”的证据：

Value pair	Tension	Evidence
Authority $\times$ Safety	approval fatigue vs protection	用户批准约 $93\%$ 的 permission prompts，单靠人工确认会降低 vigilance
Safety $\times$ Capability	performance vs defense depth	$>50$ subcommands fallback 会跳过 per-subcommand deny checks，因为解析开销导致 UI freeze
Adaptability $\times$ Safety	extensibility vs attack surface	多个 CVEs 利用 hooks/MCP servers 的 pre-trust initialization ordering
Capability $\times$ Adaptability	proactivity vs disruption	proactive AI assistants 增加 $12$–$18\%$ task completion，但高频触发降低 user preference
Capability $\times$ Reliability	velocity vs coherence	bounded context、subagent isolation 和相邻工具中的 complexity increase 共同指向 long-horizon coherence 风险

外部早期信号与论文预测一致：16 名 experienced developers、246 tasks 的 RCT 发现 AI tools 让开发者慢 $19\%$，尽管主观感觉提升 $20\%$；807 repositories 的 Cursor adoption 因果分析显示 code complexity 增加 $40.7\%$（$p<0.001$），首月 velocity spike 为 $+281\%$，第三个月回到 baseline；304,000 个 AI-authored commits / 6,275 repositories 的 audit 指向 technical-debt persistence。作者强调这些不是 Claude Code 专属结果，而是 bounded context 与 local decision-making 对 long-term coherence 的可检验预测。

Limitations

论文的限制很明确。第一，它是静态 snapshot：v2.1.88 和 feature flags（如 TRANSCRIPT_CLASSIFIER、CONTEXT_COLLAPSE）会导致不同 build 的功能差异。第二，reverse-engineering 能看到 implemented structure、control flow、dependencies 和 feature gates，但不能确认真实生产 flag、runtime prevalence、设计意图或未发布行为。第三，这是 single-system analysis，不能代表所有 coding agents。第四，OpenClaw 对照也是某个开发状态的 snapshot。第五，getSystemContext 和 getUserContext 使用 memoization，git status 与 CLAUDE.md 变化不一定每 turn 重算；这使动态 runtime behavior 比静态图更复杂。

Overall conclusion

本文最有用的结论是：未来 Code & SWE Agent 的竞争点不只是模型，也不是单纯 planner，而是 harness boundary 的设计。安全、上下文、扩展、子代理和持久化都在使用 graduated layering 而非单一机制；session transcript、compaction boundary、subagent sidechain 都偏向 append-only auditability；模型被信任在 deterministic harness 内做 contextual judgment。未来开放问题包括 silent failure 与 evaluation gap、跨 session memory、harness 在 where/when/what/with whom 四个维度上的扩张、从 session 到 scientific program 的 horizon scaling、治理审计接口，以及 long-term human capability preservation 能否成为一等架构目标。