> Deep dive into arXiv:2604.08224 *Externalization in LLM Agents* — a unified review integrating three research threads with a close reading of the original paper. > Paper: *Externalization in LLM Agents: A Unified Review of Memory, Skills, Protocols and Harness Engineering* > Authors: Chenyu Zhou et al., 21 authors (Shanghai Jiao Tong University / Sun Yat-sen University / Shanghai Innovation Institute / CMU / OPPO), submitted 2026-04-09, 54-page technical report
1. Introduction: When the 'Brain' Stops Growing but Intelligence Keeps Leaping
Swapping in a stronger base model doesn't necessarily produce a qualitative leap in agent performance; conversely, attaching persistent memory, reusable skills, and standardized tool interfaces to the same model delivers immediate gains. Anyone who has done agent engineering knows this feeling: the things outside the model matter more than the model itself.
This 54-page survey, led by Shanghai Jiao Tong University with CMU and OPPO, gives this phenomenon a unified explanatory framework — Externalization. Borrowing cognitive scientist Donald Norman's notion of 'cognitive artifacts', it punctures a counterintuitive truth: external tools never merely 'expand' the brain — they reshape the task itself.
Norman's classic example: a shopping list doesn't extend your biological memory; it transforms a hard 'recall' problem into an easy 'recognition' problem. A map doesn't make you better at navigation; it makes implicit spatial relations visibly structured. LLM agent externalization follows the same path — turning 'recall' into 'recognition', 'improvised generation' into 'structured composition', and 'ad-hoc coordination' into 'contract-based interaction'.
2. Core Thesis: Externalization as the Organizing Principle of Agent Design
The paper's central thesis:
> Externalization — progressively migrating cognitive burden from the model's internal computation into persistent, inspectable, reusable external structures — is the 'transitional logic' unifying recent advances in memory, skills, protocols, and harness engineering.
The authors stress this is not merely engineering convenience but a question of where reliable agent capability comes from:
> Reliable agent capability comes not only from bigger models, but from systematic restructuring of task demands so that internal capabilities and external infrastructure jointly cover all required competencies.
In other words, the source of capability is moving outward. The paper juxtaposes 'the cognitive externalization history of human civilization' with 'the externalization path of LLM agents', implying a recursive claim: agents are reenacting humanity's externalization arc along three representational dimensions — state, procedural expertise, and interaction structure.
3. Three Evolutionary Stages: Weights → Context → Harness
| Stage | Window | Capability Carrier | Core Mechanism | Fundamental Limits | |---|---|---|---|---| | Weights | 2022–23 | Model parameters | Pretraining compresses knowledge into weights; Scaling Law dominates the narrative | Single-fact updates require retraining/knowledge editing with side effects; hard to audit (knowledge scattered across billions of parameters); hard to personalize, compose, and govern | | Context | 2023–24 | Prompts / context window | Prompting, CoT, RAG 'release' knowledge at runtime | Limited window, overload and noise; 'lost in the middle'; each session starts fresh (partial amnesia); prompt assembly itself is brittle | | Harness | 2024–now | External persistent infrastructure | Persistent memory, tool registries, protocols, sandboxes, orchestration | The outermost layer today; its own limits lie in cost, safety risk, and governance burden |
The evolutionary core: from 'what the model knows' → 'what the model can invoke' → 'how to make the model reliably accomplish things'. Each iteration essentially offloads some cognitive burden from weights into external infrastructure.
4. Three Externalization Dimensions
4.1 Memory: Externalizing 'State Across Time'
Core transformation: from recall to recognition. The paper stratifies externalized state into four layers:
| Layer | What is externalized | Examples | |---|---|---| | Working context | Active intermediate state of the current task | Open files, temp variables, partial plans, execution checkpoints | | Episodic experience | Records of past runs | Decision points, tool calls, failures, results and reflections | | Semantic knowledge | Abstractions across episodes | Domain facts, general heuristics, project conventions | | Personalized memory | Stable information about a specific user/team/environment | Preferences, habits, recurring constraints |
Architectural spectrum (simple to complex):
- Monolithic Context: full history crammed into the prompt; easy prototyping, state vanishes with the session
- Context with Retrieval Storage: recent state kept in context, long-horizon trajectories stored externally and retrieved on demand (representatives: GraphRAG, ENGRAM, SYNAPSE)
- Hierarchical Memory: OS-style resource decoupling (MemGPT / Letta, MemoryOS: hot working state vs cold long tail, cross-layer paging); semantic decoupling (Mem0, MemoryBank, MIRIX, MemOS, xMemory: explicit 'extract–consolidate–forget' lifecycle)
- Adaptive Memory: dynamic modules + feedback-based policy optimization (MemEvolve, MemVerse, MemRL, GAM: what the authors call a paradigm shift 'from storage to control')
- Voyager: distills an executable code skill library in Minecraft, retrieved and composed by description
- Reflexion: 'verbal reinforcement learning', converting failures into reusable reflective text stored in episodic memory rather than weights
- AWM / Agent Workflow Memory: induces reusable workflows from successful trajectories
- EXTRACT: extracts transferable semantic skills from offline data, externalizing robotic procedural expertise
- Anthropic Agent Skills / SKILL.md: packages operating procedures + decision heuristics + normative constraints into explicit, registrable, progressively-disclosed, composable artifacts
- MCP (Model Context Protocol, Anthropic): JSON-RPC standardization of Agent–Tool discovery/invocation, emphasizing human-in-the-loop and permission boundaries
- A2A (Agent2Agent, Google): Agent Card + task objects for cross-vendor delegated collaboration; v1.0 uses signed Agent Cards for verifiable identity governance
- Function Calling / Tool Use: fixes 'invocation syntax + lifecycle semantics' via structured schemas — the foundational contract layer beneath higher protocols
- AG-UI: typed execution events/state streams making human-machine interaction observable and portable
- Accelerator — the cognitive flywheel: memory → skills → protocols → better execution → richer memory, forming a positive feedback loop so the system gets smarter with use.
- Brake — human approval and safety sandboxes: Anthropic Claude Code uses OS-level seatbelt/bubblewrap isolation and classifiers to replace some manual approvals (mitigating 'approval fatigue'); OpenAI Operator / CUA forces user confirmation for sensitive actions like login, payment, and CAPTCHA, with a 'monitor model' pausing on anomalies. The core principle: cap the blast radius first, approve case-by-case second — environmental hard boundaries (sandboxes/least privilege/egress controls) as the backstop, human confirmation only at critical moments.
- Models degenerate into 'empty shells': only able to call tools, with degraded zero-shot generalization and reduced system transferability
- The reverse re-internalization route: as models strengthen, some validation can be 'internalized back into weights' (e.g., Skill0.5 advocates a hybrid architecture of 'internalize cognition, externalize skills'); Lilian Weng has likewise worried that part of the harness will eventually be 'eaten' by stronger models
- Cost and risk: cognitive overhead, context burden, latency; security risks include memory poisoning, malicious skill injection, protocol spoofing; modular positive feedback amplifies errors
- Evaluation vacuum: no quantitative metric for 'degree of externalization', making it hard to isolate the causal contributions of memory/skills/protocols/harness
- RoboOS (arXiv:2505.03673): the first open-source embodied system based on a cerebrum–cerebellum hierarchical architecture. A cloud-side Embodied Brain (RoboBrain, an MLLM) handles global perception, task decomposition, and real-time replanning; an edge-side Cerebellum Skill Library (plug-and-play grasping/navigation/dexterous-hand skills) handles low-latency execution; Real-Time Shared Memory bridges the layers and enables multi-robot coordination
- Beihang AeroAgent: a drone embodied architecture explicitly framed as 'Agent as Cerebrum, Controller as Cerebellum' — the agent issues high-level commands; the controller converts waypoints into low-level commands like rotor speeds
- Industrial frameworks: CAICT divides humanoid robots into 'brain (perception/planning/decision) / cerebellum (motor control) / body' layers; SaiVLA-0 uses a frozen VLM (brain) + parallel decoder (cerebellum)
- Evaluation: lack of standardized, system- and task-level benchmarks and ablation protocols to isolate causal contributions of each externalization form; no safety certification regime for the harness layer
- Governance: privacy of personalized memory (differential privacy/right to be forgotten), multi-tenant shared-memory access control, protocol identity authentication and auditing, legal/IP provenance of externalized knowledge
- Co-evolution: how to give base models 'externalization awareness' (retrieval/protocol-sensitive pretraining) and jointly optimize with the harness end-to-end; interface stability and compatibility across model upgrades; resilience patterns for externalization failure modes (dependency chains, stale artifacts, protocol interruptions)
- Title: Externalization in LLM Agents: A Unified Review of Memory, Skills, Protocols and Harness Engineering
- Authors: Chenyu Zhou, Huacan Chai, Wenteng Chen, Zihan Guo, Rong Shan, Yuanyi Song, Tianyi Xu, Yingxuan Yang, Aofan Yu, Weiming Zhang, Congming Zheng, Jiachen Zhu, Zeyu Zheng, Zhuosheng Zhang, Xingyu Lou, Changwang Zhang, Zhihui Fu, Jun Wang, Weiwen Liu, Jianghao Lin, Weinan Zhang (21 authors)
- Institutions: Shanghai Jiao Tong University, Sun Yat-sen University, Shanghai Innovation Institute, Carnegie Mellon University (CMU), OPPO
- arXiv: 2604.08224 (cs.SE / cs.MA), submitted 2026-04-09, 54-page technical report
- Core thesis: Real-world progress in LLM agents increasingly depends on external cognitive infrastructure beyond the model (memory/skills/protocols + Harness) rather than stronger models per se; externalization reshapes hard tasks into forms the model can solve more reliably via 'representational transformation'
- DOI: https://doi.org/10.48550/arXiv.2604.08224
Representative works: MemGPT (OS virtual-memory metaphor), Generative Agents (memory stream + reflection + retrieval), ReadAgent (gist-based memory paging), A-MEM (Zettelkasten-style dynamic linking), Zep (temporal knowledge graph Graphiti).
4.2 Skills: Externalizing 'Procedural Expertise'
Core transformation: from generation to composition — agents assemble behavior from pre-validated components instead of improvising each step. The paper classifies skill acquisition as Authored / Distilled / Discovered / Composed, with an evolution path: Atomic Execution Primitives → large-scale primitive selection → encapsulation into governable skill artifacts. Representatives:
4.3 Protocols: Externalizing 'Interaction Structure'
Core transformation: from ad-hoc to structured — vague, fragile communication becomes interoperable, governable exchange. Protocol taxonomy (paper §5.2): Agent-Tool, Agent-Agent, Agent-User, Other; elements include intent capture, capability discovery, session lifecycle, permission and trust boundaries. Representatives:
5. Harness Engineering: The Substrate That Governs Everything
The paper is explicit: the Harness is not a fourth externalization, but the engineering layer and runtime environment hosting the other three — it provides orchestration logic, constraints, observability, and feedback loops that congeal externalized cognition into controlled execution.
Analysis dimensions (paper §6.2): Agent Loop, sandboxing and execution isolation, human oversight and approval gates, observability, configuration/policy, context budgeting.
In practice, the Harness plays two seemingly contradictory but complementary roles:
Representative Harness systems: Claude Code / Agent SDK, Cursor, OpenAI Agents SDK, LangGraph (directed-graph state machine + checkpoints + human-in-the-loop), AutoGen / AG2, CrewAI.
6. Trade-offs: Parametric vs Externalized Capability
Externalization is not a free lunch. The paper (§7.3) lists the trade-off space: update frequency/decay, reusability/portability, auditability/governability, latency/context burden.
The Chinese community and practitioners have pointed out a sharper 'over-externalization trap':
7. Embodied Intelligence: The Cerebrum–Cerebellum Split
The paper (§8.2) extends the direction from digital agents to Embodied Externalization, proposing 'decomposition: the cerebrum–cerebellum split' — projecting externalization theory into the physical world by moving real-time motor control and procedural expertise that large models handle unreliably out of the model and into external executable structures.
Representative architectures:
8. Shared Cognitive Infrastructure: Vision and Challenges
The paper anticipates two main lines:
1. Self-Evolving Harnesses: the harness itself moves from configuration to control, adjusting orchestration and constraints based on feedback 2. Shared Agent Infrastructure: from private scaffolding to shared artifacts and standards — cross-vendor protocol ecosystems, organization-level 'Agent OS' (memory as shared, governed state with unified scheduling and auditing), public-sector transparent harnesses
Open challenges (§8.4 / §8.6):
9. What This Revolution Really Means
First, the 'parameter-count faith' indeed needs cooling, but not a reversal into 'Harness omnipotence'. The paper's value lies not in coining a term but in elevating scattered experience into 'cognitive architecture restructuring' — memory/skills/protocols now have explicit cognitive functional positions rather than being a pile of technical component labels. That is a real contribution.
Second, layered, not mutually exclusive. Weights→Context→Harness is not substitution but a continuous outward migration of capability centers. Strongest practice is often an 'internalize + externalize' hybrid (the Skill0.5 idea); blind externalization turns the model into an empty shell.
Third, the Harness is the engineering layer most worth betting on today. Memory, skills, and protocols all have mature solutions; what's truly scarce is the 'operating system kernel' that unifies them into controlled execution — sandboxing, approval, observability, feedback loops. The Claude Code vs LangGraph contest is precisely a contest over this layer.
Fourth, embodiment is the ultimate proving ground for externalization. The cerebrum–cerebellum split demonstrates that externalizing 'difficult but reliability-critical' low-level control is the key to robots leaving the lab. Society-wide shared cognitive infrastructure is the farther vision — without governance and evaluation keeping pace, it remains a pie in the sky.
One-sentence takeaway: A better agent is not a better reasoner, but a better-organized cognitive system. That is the true meaning of the 'cognitive infrastructure revolution'.
---