PaperlayerView exact revision on arXiv

Source-linked AI summary

Externalization in LLM Agents: A Unified Review of Memory, Skills, Protocols and Harness Engineering

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

arXiv:2604.08224v1cs.SEcs.MA

TL;DR

LLM agents face continuity, procedural-variance, and coordination problems that internal model capability alone does not fully address. This paper reviews how externalization relocates these burdens into memory, skills, protocols, and harness infrastructure, concluding that reliable agency depends on coordinated internal and external capabilities. The framework also identifies context limits and security risks as boundaries for this approach.

  • Problem

    Practical agent reliability is not fully explained by model scale because agents face continuity, procedural, coordination, and context-management mismatches.

  • Method

    The paper presents a systems-level review organized around cognitive externalization across memory, skills, protocols, and harness engineering.

  • Results

    Externalization changes the task agents solve: memory supports retrieval, skills support guided composition, protocols support structured exchange, and the harness coordinates these layers.

  • Takeaways & Limitations

    Reliable agency increasingly depends on explicit infrastructure that coordinates externalized state, expertise, and interaction rather than relying on model weights alone.

  • Takeaways & Limitations

    Externalized artifacts introduce security risks including memory poisoning, malicious skill injection, and protocol spoofing.

Abstract

from arXiv · show

Large language model (LLM) agents are increasingly built less by changing model weights than by reorganizing the runtime around them. Capabilities that earlier systems expected the model to recover internally are now externalized into memory stores, reusable skills, interaction protocols, and the surrounding harness that makes these modules reliable in practice. This paper reviews that shift through the lens of externalization. Drawing on the idea of cognitive artifacts, we argue that agent infrastructure matters not merely because it adds auxiliary components, but because it transforms hard cognitive burdens into forms that the model can solve more reliably. Under this view, memory externalizes state across time, skills externalize procedural expertise, protocols externalize interaction structure, and harness engineering serves as the unification layer that coordinates them into governed execution. We trace a historical progression from weights to context to harness, analyze memory, skills, and protocols as three distinct but coupled forms of externalization, and examine how they interact inside a larger agent system. We further discuss the trade-off between parametric and externalized capability, identify emerging directions such as self-evolving harnesses and shared agent infrastructure, and discuss open challenges in evaluation, governance, and the long-term co-evolution of models and external infrastructure. The result is a systems-level framework for explaining why practical agent progress increasingly depends not only on stronger models, but on better external cognitive infrastructure.

1 Introduction

The paper frames LLM-agent progress as cognitive externalization: relocating burdens from model computation into persistent, reusable infrastructure that changes the tasks agents solve. Memory, skills, and protocols externalize distinct burdens, while harness engineering coordinates them into reliable execution.

  • Cognitive externalization: Cognitive artifacts improve problem solving by transforming tasks rather than simply increasing internal capability.The paper applies this representational-transformation lens to LLM-agent design.
  • From weights to harness: LLM-agent design has moved from weights toward context and harness infrastructure as capabilities increasingly reside in the surrounding runtime.The paper describes this progression as a shift outward from the model itself.
  • Memory: Memory externalizes state across time, converting continuity demands into selective retrieval from persistent stores.It preserves preferences, trajectories, ambiguities, and facts beyond individual sessions.
  • Skills: Skill systems externalize procedural expertise by packaging task-specific know-how into reusable operating guidance.This changes behavior from repeated improvisation to composition from pre-validated components.
  • Protocols: Protocols externalize interaction structure through interoperable, machine-readable contracts for tools, services, and agents.They replace ambiguous prompt-level coordination with governed exchange.
  • Harness engineering: Harness engineering unifies memory, skills, and protocols through orchestration, constraints, observability, feedback loops, and control points.The harness is the runtime environment in which these externalized modules operate and interact.

2 Background: From Weights to Context to Harness

LLM agent development has progressively externalized capability from weights to context and then to harness infrastructure. This shift relocates mutable knowledge, procedures, and interaction rules into explicit structures that make runtime behavior more manageable.

  • From Weights to Context to Harness: The agent stack evolved from weight-centric capability toward context and harness layers, while weights remain foundational.The layers are sequential but overlapping rather than mutually exclusive.
  • Capability in Weights: Weight-space capability offers compact deployment and broad generalization but couples knowledge, procedure, and policy to a static, difficult-to-audit artifact.Selective updates, composition, governance, and personalization are consequently difficult.
  • Capability in Context: Context externalization uses prompts and retrieval to stage instructions, domain knowledge, schemas, and evidence at runtime without gradient updates.It converts some recall demands into recognition and application of supplied information.
  • Capability in Context: Finite, costly, noisy, and ephemeral context limits prompt-only control over long-horizon state, workflows, coordination, recovery, and behavioral constraints.Long inputs can also degrade retrieval through uneven attention.
  • Capability in the Harness: Harness infrastructure absorbs memory, skills, and protocols: it externalizes state across time, procedural expertise, and interaction structure.The harness also includes persistent stores, tool registries, sandboxes, orchestration, compression, and related runtime mechanisms.
  • Externalization as the Transition Logic: Externalization transforms the model’s task by moving mutable knowledge, reusable procedures, and interaction rules into explicit artifacts and harness logic.The resulting structures make constraints, observability, and feedback loops explicit.

3 Externalized State: Memory

Memory externalizes continuity across sessions and long horizons by converting transient history into managed, selectively retrieved state. Its value depends on representational design and control, not merely on storage capacity.

  • What Is Externalized: Memory preserves continuity by externalizing current task state, prior experience, abstracted knowledge, and persistent user or environment context.These records span multiple temporal and abstraction levels rather than forming one homogeneous database.
  • What Is Externalized: Working context stores live task state such as files, variables, hypotheses, plans, and checkpoints so interrupted agents can resume without reconstruction.Workspace artifacts and terminal state are materialized outside the prompt.
  • Memory Architectures: Memory architectures progress from monolithic context and retrieval stores to hierarchical orchestration and adaptive systems that manage extraction, consolidation, forgetting, and strategy optimization.The progression moves from storage and retrieval toward organization and policy.
  • What Is Externalized: Episodic experience records decisions, tool calls, failures, outcomes, and reflections that can provide precedents, prevent repeated mistakes, and support later abstraction.Reflective summaries from failed attempts are one explicit example.
  • Memory Demands of the Harness Era: Harness-era memory separates authoritative state from context, supplying curated snapshots to planning and execution instead of replaying unrestricted history.File-centric state abstractions write plans, variables, and tool outputs in real time and expose only selected workspace content and recent actions.
  • Memory and Governance: Shared memory requires permissions, conflict resolution, access quotas, and other operating-system-like controls for multi-agent governance.Memory therefore becomes managed state infrastructure rather than an isolated archive.
  • Memory as Cognitive Artifact: Retrieval quality matters more than raw storage capacity because indexing, summarization, and contextual selection determine whether history becomes usable for reasoning.Large stores with weak retrieval preserve history without transforming the task representation.
  • Memory as Cognitive Artifact: Stale, over-abstracted, under-abstracted, poisoned, or conflicting memories fail by presenting an unusable representation of the present.These failures arise from representational design rather than storage quantity alone.

4 Externalized Expertise: Skills

Skills externalize procedural expertise by replacing repeated workflow synthesis with reusable, discoverable, and composable operating structures. Their reliability depends on activation, execution context, and boundary conditions.

  • The Procedural Burden: Skill externalization addresses procedural variance caused by repeatedly reconstructing workflows, defaults, constraints, and branching decisions.The resulting failures include omitted steps, unstable tool use, and inconsistent stopping conditions.
  • Skills as Externalized Expertise: Skills package know-how into explicit artifacts that can be discovered, loaded, revised, and composed instead of regenerated from weights or ad hoc prompts.This changes runtime work from inventing a workflow to selecting and following a reusable procedure.
  • Skills in the Harness: In harnessed agents, skills connect retrieved state to action by binding procedures to tools, subagents, and protocolized interfaces.Execution traces and reflection can update skills, while memory supplies the experience from which they are formed.
  • Skill Lifecycle: A skill lifecycle covers acquisition, artifact packaging, registry-based activation, composition, and runtime execution.Artifacts include procedures, decision heuristics, normative constraints, and manifests specifying capabilities, preconditions, and scope.
  • Skill Lifecycle: Staleness, limited portability, context-dependent degradation, and unsafe composition constrain skill reliability.These boundary conditions affect whether an activated skill remains appropriate in a particular runtime.

4.1 What is Externalized: Procedural Expertise

Skills externalize procedural expertise by making task structure, local decision policy, and acceptable operating boundaries explicit and reusable. This converts fragile process knowledge into governed execution that can remain stable across tasks, contexts, and runs.

  • Operational Procedure: Operational procedures decompose complex tasks into steps, phases, dependencies, and stopping conditions, reducing process-level errors such as skipped or misordered operations.Externalized procedure turns the task skeleton into an explicit operating path.
  • Operational Consequences: Externalized procedures let agents resume after interruption, transfer work across contexts or collaborators, and recover state without reconstructing the workflow from memory.These benefits are especially relevant in long-horizon, multi-agent, and production settings.
  • Decision Heuristics: Decision heuristics encode default choices, escalation rules, and preference orderings so agents need not rediscover local policy at every branch.This reduces deliberation cost and stabilizes behavior under noisy observations, tool failures, and competing actions.
  • Normative Constraint: Normative constraints make testing, scope, access, traceability, and domain-specific rules part of task execution rather than merely post hoc evaluation.They can establish preconditions, block unsafe branches, require validation, or specify completion evidence.
  • Integrated Skill: A reusable skill combines operational procedures, decision heuristics, and normative constraints strongly enough to survive across tasks, contexts, and runs.Skills externalize repeatable task know-how rather than past state or raw execution primitives.

4.2 From Execution Primitives to Capability Packages

Skill systems mark a shift from reliable action execution and tool selection toward reusable capability packages centered on procedural guidance. The abstraction changes from isolated tool access to transferable, composable know-how for completing task classes.

  • Execution Primitives: Tool invocation provides stable access to atomic action units but does not supply reusable procedures for completing broader task classes.Structured interfaces and function calling help models decide when to call tools, construct arguments, and incorporate results.
  • Tool Selection: As tool collections expand, retrieval, ranking, and dynamic selection make action choice scalable, but the fundamental unit remains the individual tool rather than the procedure.Multi-step behavior may emerge without packaging the underlying know-how as a reusable artifact.
  • Capability Packages: The capability-package stage treats reusable procedural guidance and execution structure as the fundamental unit of agent capability.The central question becomes whether a class of task know-how can be packaged into a reusable capability unit.
  • Skill Induction: Program-based induction and trajectory distillation compile primitive actions or interaction traces into reusable skills, libraries, and skill APIs.These approaches allow capabilities to accumulate and transfer across tasks.
  • Representational Shift: Externalized capability is increasingly represented as packaged procedural knowledge that can be loaded, reused, and composed across tasks.This is a representational shift beyond making tool use more complex.

4.3 How Skills Are Externalized

Skill externalization is a coordinated representational and runtime process: expertise is specified, discovered, selectively disclosed, bound to executable substrates, and composed into larger capability structures. A skill becomes useful when it reliably enters the runtime as a usable, interoperable unit of action.

  • Representational and Runtime Layers: Skill externalization requires both a representational layer describing procedural expertise and a runtime layer that makes it function as reusable capability.The representation determines how a skill is described and delimited; the runtime determines whether it can operate in practice.
  • Specification: Skill specifications describe capabilities, applicability, dependencies, constraints, and input-output conditions through artifacts such as SKILL.md files and manifests.They function more like API documentation than implementation.
  • Specification: Well-formed specifications should state capability boundaries, applicability, preconditions, execution constraints, and examples with counterexamples.These categories clarify intended use, safe operating assumptions, and concrete usage patterns.
  • Discovery: Skill registries and discovery mechanisms selectively retrieve procedural expertise based on task goals, context, decomposition, metadata, and environmental assumptions.The matching problem concerns which procedural unit fits the present problem, not merely which tool can be called.
  • Selective Disclosure: Progressive disclosure exposes a skill’s existence first and loads deeper instructions only when needed, limiting reasoning noise from excessive context.Layered implementations may reveal a description, manifest conditions, and finally the full guide.
  • Composition: Composition turns skills into schedulable runtime units, supporting serial, parallel, conditional, and recursive coordination while improving maintainability, replaceability, and auditability.Complex capabilities can combine smaller skills such as data cleaning, analysis, visualization, and narrative synthesis.

4.4 Skill Acquisition and Evolution

Skill acquisition is an ongoing evolutionary process in which procedural knowledge is authored, distilled from experience, discovered through interaction, and composed from existing capabilities. Mature systems systematize this loop so experience can become reusable externalized expertise.

  • Authored: Manual authoring remains a stable route for introducing skills and supports iterative revision when deployment reveals recurring failure patterns.Examples include SKILL.md, AGENTS.md, project instruction files, and organizational SOP templates.
  • Distilled: Trajectory distillation abstracts recurring successful structures from episodic records into more stable procedural units.Memory preserves experience, while skill induction extracts reusable structure from it.
  • Discovered: Autonomous discovery can produce expanding executable skill libraries through environmental interaction, feedback, self-verification, and curriculum-driven task selection.Voyager provides an example in the Minecraft setting.
  • Composed: Composition acquires higher-level capabilities by repeatedly coordinating validated lower-level or mid-level skills.Complex workflows such as report generation or code repair can emerge from existing capabilities.
  • Evolutionary Loop: A mature skill system is defined by how effectively it turns experience into reusable expertise rather than by how many instructions it stores.In a harnessed agent, memory supplies evidence, evaluators decide what merits promotion, and protocolized execution surfaces the resulting expertise.

4.5 Boundary Conditions

Skill externalization improves reuse and governance but does not guarantee reliability. Its effectiveness remains bounded by semantic alignment, environmental portability and freshness, composition safety, and context-dependent degradation.

  • Semantic alignment: Skill effectiveness depends on alignment among task intent, skill description, invocation decision, and execution environment.Literal adherence can still miss the task’s real objective when descriptions and use diverge.
  • Portability and staleness: Skills can become misleading or obsolete as websites, APIs, dependencies, workflows, and runtime conventions change.Their behavior also varies across frameworks, tool substrates, domains, and model-agent configurations.
  • Unsafe composition: Composing skills can introduce security risks, including prompt injection, data exfiltration, privilege escalation, and supply-chain vulnerabilities.Risk can emerge from interactions among artifacts and their connecting interfaces, even when individual skills appear harmless.
  • Context-dependent degradation: Skill execution can degrade during extended interaction because residual context, cached summaries, or excessive procedural detail disrupt current task tracking.Updated skills may not immediately displace outdated operational patterns retained in the session.
  • System boundary: Skills must be treated as components embedded in a broader engineering framework rather than self-sufficient, stable modules.Their effectiveness depends on continued alignment with tasks, environments, runtime conditions, and security constraints.

4.6 Skills in the Harness

Skills become operationally reliable through harness couplings with memory, protocols, governance, and lifecycle feedback. The harness contextualizes skill selection, binds skills to executable interfaces, controls risk, and feeds execution evidence into revision.

  • Conditioning on memory: Memory supplies task history, prior outcomes, user context, and environmental constraints for contextual skill selection and parameterization.Without this conditioning loop, selection degenerates into keyword matching.
  • Binding through protocols: Protocols ground selected skills in executable actions through schemas, delegation contracts, file operations, and approval workflows.The harness resolves available endpoints, checks permissions, and routes steps to execution substrates.
  • Runtime governance: Runtime governance adds permission checks, approval gates, audit logging, and rollback mechanisms around skill execution.These controls belong to the harness environment, not the skill artifact itself.
  • Lifecycle feedback: Execution traces, success rates, failures, and user corrections are written to memory and can trigger skill revision, deprecation, or promotion.The harness therefore provides the feedback infrastructure through which skills evolve.

4.7 Skill as Cognitive Artifact

Viewed as cognitive artifacts, skills reorganize procedural expertise by moving it from opaque parameters into explicit, inspectable external structures. This shifts inference from reconstructing procedures toward contextual matching, following guidance, and handling exceptions.

  • Theoretical framing: Cognitive-artifact theory frames skills as representational transformations that reorganize how procedural capability is accessed.The paper uses this theory primarily as a theoretical interpretation rather than direct empirical evidence.
  • External representation: Without skills, the model repeatedly reconstructs procedural knowledge from parameters during execution.Externalization makes procedural structure available as an explicit object that can be loaded, inspected, and followed.
  • Inference-time burden: Externalized skills shift the model’s burden toward interpreting situations, recognizing applicability, following guidance, and handling local exceptions.Procedural knowledge no longer must be reconstructed from scratch on every run.
  • Complementary strategies: Skills externalize procedure definitions, constraints, and best practices while leaving contextual matching and exception handling to the model.They support complementary strategies that offload some cognitive work into the environment.
  • System-scale significance: At system scale, skills convert repeated workflow invention into selection, loading, and composition under runtime control.This makes procedural competence inspectable, revisable, composable, and reusable rather than merely adding information.

5 Externalized Interaction: Protocols

Protocols externalize the interaction contracts that let agents exchange information and actions across system boundaries. They replace free-form communicative inference with structured, governable mechanisms for invocation, lifecycle coordination, permissions, discovery, interoperability, and presentation.

  • Interaction burden: Without explicit contracts, models must improvise message formats, argument structures, lifecycle semantics, permissions, and recovery behavior for every external action.This makes tool use, delegation, and user-facing responses fragile prompt-following exercises.
  • Invocation grammar: Schemas and typed interfaces make the model fill invocation fields rather than infer or reinvent syntax.This externalizes argument names, types, ordering, and return structure.
  • Lifecycle semantics: State machines or event streams externalize sequencing rules for multi-step interactions, including allowed transitions and completion or failure states.The model no longer carries all lifecycle coordination in its inference process.
  • Permission and trust boundaries: Inspectable protocol rules externalize authorization, data-flow constraints, and evidence requirements for runtime enforcement.This makes permission and trust boundaries explicit rather than relying on model self-policing.
  • Discovery metadata: Registries, capability cards, and schema endpoints make available capabilities queryable instead of embedding discovery knowledge implicitly in prompts.Discovery becomes an explicit protocol surface.
  • What protocols externalize: Protocols specify interaction grammar, lifecycle, permissions, and discovery so tools and skills become executable across system boundaries.Tools expose operations, skills encode procedures, and protocols govern how both are invoked and connected.
  • Benefits: Unified protocols support interoperability, structured delegation, explicit state exchange, and more portable multi-agent collaboration.Common representations are needed before delegation and context transfer can be automated across runtimes.
  • Benefits: Protocols make permissions, identity, traces, failure states, and responsibility boundaries explicit for security, governance, and auditability.Runtime validation and operator auditing become possible when implicit glue logic is formalized.

5.3 Agent Protocol in Harness Engineering

Harness Engineering externalizes protocol burdens by turning model-generated language into validated, typed, lifecycle-aware actions. This shifts fragile interaction semantics from latent inference into inspectable interfaces while preserving model judgment and intent.

  • Intent capture and normalization: Protocol surfaces translate model-produced language into explicit commands or events that runtimes can validate and execute.Intent capture and normalization make execution semantics explicit rather than dependent on interpreting free-form language.
  • Capability discovery and tool description: Protocolized tool discovery exposes available tools, schemas, and input/output structures through standardized metadata.This replaces prompt- and assumption-based tool knowledge with an explicit capability surface.
  • Capability discovery and tool description: Structured capability metadata reduces context inflation and makes permissions, versioning, and auditing enforceable.The model reads declared capability boundaries instead of guessing what can be called.
  • Session and lifecycle management: Lifecycle protocols preserve identifiers, roles, pending actions, phase transitions, and allowed next moves across long-running executions.Protocol state maintains interaction continuity, while persistent outputs and checkpoints become memory.
  • Protocol as cognitive artifact: Protocols transform external action from open-ended natural-language inference into a bounded task involving typed fields and explicit constraints.This representational change removes classes of reasoning from the critical path and reduces coordination decisions.
  • Protocol as cognitive artifact: Protocols divide labor with models: models provide judgment and intent, while protocol surfaces provide format, validation, and lifecycle control.Together they produce interaction that is flexible yet disciplined.

6 Unified Externalization: Harness Engineering

Harness Engineering unifies memory, skills, and protocols within a governed runtime that coordinates access, action, constraints, feedback, and context. Contemporary systems converge on recurring harness dimensions because effective agency depends on operational conditions, not model completions alone.

  • What is a Harness?: A harness coordinates externalized modules across perception, action, constraint, monitoring, and feedback within one operational envelope.Module-level externalization improves local capability, but agenthood requires global coordination over time.
  • What is a Harness?: Agency emerges from coupling a model with a harness that governs context access, tool invocation, state preservation, and feedback.The harness supplies the operational structure that a foundation model alone lacks.
  • What is a Harness?: The harness changes what the model must reason about by providing persistent context, reusable routines, protocolized interfaces, and runtime infrastructure.Its representational role is collective rather than dependent on a fixed component inventory.
  • Observability: Inspectability through observability enables debugging, auditing, and improvement by exposing the agent’s internal trajectory.Structured traces make behavior visible to developers, operators, and the agent itself.
  • Context management: Finite context is a harness-level coordination problem because memory, skills, schemas, tool descriptions, and reasoning traces compete for one token budget.Summarization, staged loading, and priority eviction jointly allocate context according to execution phase.
  • Harness in practice: Production harnesses converge on explicit loops, sandboxing, approval gates, structured traces, scoped governance, and active context management.These recurring dimensions appear across independently developed systems and define the operational environment for coherent agency.
  • Harness in practice: Harness engineering concerns constructing the cognitive and operational environment in which externalized modules compose into coherent agency.It is broader than memory systems or tool calling alone.

7 Cross-Cutting Analysis

Memory, skills, and protocols form coupled flows inside the harness: experience informs skills and routing, skills generate traces and invoke governed actions, and protocols create normalized feedback. These reinforcing loops expand capability while introducing risks from poor distillation, execution failures, latency, and context burden.

  • Module interaction map: The harness unifies memory, skills, and protocols so their interactions can be analyzed at the model boundary and across parametric and externalized capability.The modules are analytically distinct but derive system-level power from their coupling.
  • Memory to skill: Repeated trajectories can be distilled into reusable skill artifacts, allowing accumulated experience to become codified expertise without changing model weights.The quality of distillation determines whether downstream skills encode generalizable or situational behavior.
  • Skill to memory: Execution traces, failures, and refinements become durable evidence for validating, revising, splitting, or constraining skills.Continuous recording gives skill maintenance an empirical basis instead of allowing procedures to become stale.
  • Skill to protocol: Protocols turn skills into governed actions by translating procedures into typed calls, lifecycle events, and permission-checked interactions.Protocol validation can intercept forbidden or malformed operations even when the skill itself is well written.
  • Protocol to skill: Stable protocol contracts expand the surface for authoring reusable skills by making interface-specific know-how portable rather than ad hoc.The pace and quality of protocol standardization condition growth of the skill-artifact ecosystem.
  • Memory to protocol: Stored context can make protocol selection experience-informed by using historical successes, user preferences, and prior failures to choose interaction paths.In multi-agent settings, routing may select local execution, tool invocation, or delegation.
  • System-level dynamics: Positive feedback among memory, skills, and execution traces can accelerate capability growth but also amplify errors through contaminated downstream artifacts.A poisoned memory entry may produce a flawed skill whose traces further contaminate memory, requiring harness-level intervention.
  • Trade-offs: Externalization adds latency, retrieval and routing costs, and context burden, while excessive loading can degrade performance through information overload.The optimal partition leaves persistence-, reuse-, and control-sensitive burdens outside the model while retaining stable generic competencies inside it.

8 Future Discussion

The paper extends externalization beyond current agent architectures into self-evolving harnesses, multimodal and embodied systems, shared infrastructure, and evaluation. These directions also expose growing costs in cognitive overhead, security, governance, and measurement.

  • Self-evolving harnesses: Future harnesses may externalize planning artifacts, evaluation procedures, and orchestration logic so agents can inspect and revise how they organize work.Plans become persistent objects, verification becomes a runtime component, and harness configuration itself becomes inspectable and revisable.
  • Multimodal externalization: Multimodal externalization must extend memory, skills, and protocols beyond text to support visual, audio, video, and screen-based representations.The current framework assumes text as the dominant medium, creating new design demands for multimodal foundation models.
  • Embodied systems: Embodied agents face the same planning-execution tension as digital agents, but physical irreversibility, tight latency budgets, noisy perception, and sim-to-real gaps impose additional constraints.Externalization can separate persistent planning and memory from specialized low-latency execution modules.
  • Trade-offs and risks: Externalization introduces cognitive overhead and security risks because additional retrieval layers, schemas, rules, and artifacts can burden reasoning or become attack surfaces.Over-retrieval and overlapping skills consume context, while memory poisoning and malicious skill injection threaten system integrity.
  • Shared infrastructure: Shared memory, skills, and protocols can support division of labor and collective learning, but institutionalized infrastructure requires provenance, permissions, version control, and rollback.Failure trajectories can accumulate in shared memory while successful paths crystallize into shared skills; shared infrastructure also risks drift and low-quality artifacts.
  • Evaluation: Current benchmarks under-measure externalized infrastructure because they evaluate task completion under fixed prompts and settings without attributing gains to memory, skills, or governance.Externalization may appear only as a higher pass rate, obscuring which infrastructure component improved reliability.

9 Conclusion

The conclusion presents externalization as the transition logic connecting memory, skills, protocols, and harnesses in reliable LLM agents. It reframes progress as organizing capability across models and infrastructure, while leaving evaluation and governance as central agenda items.

  • Externalization as transition logic: Reliable agency increasingly depends on relocating selected cognitive burdens into memory, skills, protocols, and a coordinating harness.Memory externalizes state across time, skills procedural expertise, protocols interaction structure, and the harness coordinates these layers.
  • Weights, context, and harness: The shift from weights to context to harness changes where agent capability is organized, making some burdens more reliable when they are persistent, inspectable, reusable, and governable.The paper does not treat externalization as replacing all parametric capability; some burdens remain well handled by the model.
  • Representational transformation: Externalization works through representational transformation: memory turns recall into retrieval, skills turn improvisation into guided composition, and protocols turn ad hoc coordination into structured exchange.The resulting infrastructure changes the task the model is asked to solve rather than merely adding components around it.
  • Research agenda: The resulting research agenda concerns partitioning capability between models and infrastructure, evaluating externalized contributions, and governing shared artifacts.These questions define the next stage of systems-level agent design.
  • Co-evolution: Agent progress is framed as co-evolution between models and external infrastructure, producing better-organized cognitive systems rather than merely better reasoners.The conclusion treats neither stronger models nor infrastructure alone as sufficient.
Loading 2604.08224v1…