Why a Runtime-Centric Architecture Is a Stronger Model for Agent Engineering
A reply to The Harness Behind Reliable LLM Agents, the post that introduced the diagram A Harnessed LLM Agent.
The diagram A Harnessed LLM Agent makes an important point: a capable agent is more than an LLM connected to a collection of tools. It needs reusable skills, memory, interaction protocols, execution controls, and mechanisms for evaluating its behavior.
That is a useful conceptual overview. But a conceptual overview is not automatically a sound reference architecture.
The diagram presents four ideas—Skills, Harness, Memory, and Protocols—as its main categories. The problem is that these ideas describe different architectural dimensions. Skills describe capabilities; Memory describes retained information; Protocols define interaction contracts; and Harness concerns execution and control. They are related, but they are not equivalent building blocks.
My argument is not that the four categories are wrong or unimportant. It is that listing them as four top-level categories obscures the relationships that make an agent work. For engineering purposes, a Runtime-Centric Agent Architecture is a more coherent starting point: the runtime coordinates the model, capabilities, state, protocols, and environment within a controlled execution lifecycle.
1. The Four Categories Do Not Belong to the Same Architectural Level
The original diagram groups four concepts that are useful to distinguish:
| Concept | What it describes | The question it answers |
|---|---|---|
| Skills | Reusable capabilities and procedures | What can the agent do? |
| Harness | Execution and control mechanisms | How is the agent run and managed? |
| Memory | Retained information and knowledge | What does the agent remember? |
| Protocols | Communication contracts | How does the agent interact with users, other agents, and tools? |
These are different dimensions, not four interchangeable subsystems.
Consider a coding agent asked to fix a bug. A skill may describe how to investigate a failure and modify code. Memory may provide repository conventions and relevant past findings. A protocol may define how the agent requests a tool operation. The runtime decides when to invoke the model, which action to dispatch, whether that action is allowed, how to capture its result, and whether the task should continue.
The distinction matters because the four concepts do not have symmetrical responsibilities. A skill does not own the task lifecycle. A protocol does not execute an operation merely by defining message formats and interaction rules. Memory does not decide which information is authoritative for the current task. The runtime coordinates these mechanisms as part of one execution process.
A useful architecture should make those relationships explicit rather than flatten them into a list of neighboring concepts.
2. Harness Should Be Understood as the Agent Runtime
The diagram presents the Harness as a collection of components around an agent: sandbox provisioning, sub-agent orchestration, observability, compression, evaluation, and approval loops. That arrangement is reasonable. However, Harness should mean more than a collection of utilities grouped around an agent.
It is better understood as the runtime and control infrastructure that manages the agent's execution lifecycle.
The model provides inference: it interprets context and proposes decisions or actions. The runtime turns those proposals into managed execution. It validates proposed actions, applies policy, dispatches operations, collects observations, updates state, and determines what happens next.
For example, when a model proposes a shell command, the runtime may need to:
- Validate the proposed tool call and its arguments.
- Check whether the agent is authorized to perform the operation.
- Select an appropriate execution environment, including a sandbox where needed.
- Execute the operation and capture its output.
- Associate the result with the correct task and execution step.
- Evaluate the result against the current step and the overall objective.
- Continue, retry, request approval, or terminate the task.
The model can propose an action, but it should not be the ultimate authority on whether that action is permitted or whether it actually succeeded. Those guarantees belong to the runtime and the systems around it.
A concise definition is therefore:
Definition. Harness is the runtime and control infrastructure around an LLM. It manages the agent's lifecycle: assembling context, orchestrating actions, dispatching operations, transitioning state, processing feedback, enforcing policy, evaluating results, and supporting recovery.
The runtime coordinates these responsibilities; it does not own every policy or quality function it relies on. This definition also clarifies that Harness is not necessarily one deployable service or one monolithic process. It is a logical responsibility that may be implemented by several cooperating components.
3. The Execution Loop Is the Missing Architectural Center
The most important property of an agent is not that it contains several categories of components. It is that it can pursue an objective through repeated cycles of decision, action, and observation.
A simplified execution loop looks like this:
User Goal / Trigger
|
v
Context Assembly
Inputs: Skills + Memory + Task State
+ Relevant Policy
|
v
Model Inference
Reasoning / Decision
|
v
Policy & Authorization Check
|
v
Action Dispatch
Tools / Skills / Agents
|
v
Environment
|
v
Observation and Evaluation
|
v
State and Context Update
|
+-----------> Next inference
Or: Complete / Escalate
The runtime manages this loop.
This makes the difference between a one-shot model interaction and an agent system clearer:
One-shot interaction:
Input -> Model -> Response (or one tool call)
Managed agent execution:
Goal -> Context -> Inference -> Action -> Observation
-> Evaluation -> State Update -> Next Decision -> ...
The first produces a response or a single action; the second manages a task over time.
This is why planning, tool dispatch, evaluation, checkpointing, cancellation, retries, and recovery should be understood as parts of the runtime's execution responsibilities—not merely as a collection of optional features around a model.
4. Memory, State, and Context Are Different Things
The original diagram identifies Working Context, Episodic Experience, Semantic Knowledge, and Personalized Memory—roughly, working context, episodic memory, semantic knowledge, and user profile. These are useful ideas, but they mix different classification criteria.
Working Context is primarily about what is assembled for a particular inference step. Episodic and semantic memory describe types of retained information. A user profile describes information from the perspective of a particular user. These categories can overlap: a user's preference, for example, may be stored as a semantic fact and also appear in a user profile.
A more precise design separates operational state from persistent memory—and distinguishes both from context.
Operational state
Operational state represents what is happening in the current execution:
- Task status and objective
- Current plan and completed steps
- Pending actions and tool calls
- Intermediate results
- Sub-agent assignments and results
- Approval status
- Checkpoints needed for resumption
This state is part of the execution record. It must remain authoritative even when the model's context is shortened or reconstructed.
Persistent memory
Persistent memory contains information that may be useful beyond the current execution:
| Type | Examples |
|---|---|
| Episodic | Previous tasks, events, outcomes, and feedback |
| Semantic | Facts, concepts, entities, and relationships |
| Procedural | Methods, strategies, and learned ways of performing tasks |
| Profile | User preferences, project conventions, and organizational context |
A second distinction matters as much: state versus context. Operational state is the underlying record of the execution. Context is the selected information assembled for a particular model call. Context can be compressed or reconstructed; omitting a fact from the prompt must not delete it from state.
Skills and procedural memory are related but should not be conflated. Procedural memory retains knowledge about how to perform a task. A skill is an engineered, reusable package—instructions, resources, constraints, and sometimes executable logic—that exposes a procedure through an interface the runtime can invoke.
5. Protocols Define Contracts; They Do Not Provide Execution by Themselves
The diagram groups Agent–User, Agent–Agent, and Agent–Tools under Protocols. This is a reasonable way to classify interaction patterns, but it can blur the boundary between communication and execution.
A protocol fixes message formats and interaction rules, but it leaves authorization, dispatch, and result correlation unspecified.
A tool interaction, for example, may involve several distinct responsibilities:
Model
-> Tool-calling contract
-> Tool dispatcher
-> Authorization and policy checks
-> Tool runtime
-> External environment
-> Result capture and correlation
The protocol defines the contract. The dispatcher routes the request. Authorization determines whether the operation is allowed. The tool runtime performs the operation. The environment produces the actual effects.
The same distinction applies to agent-to-agent collaboration. A communication protocol can standardize message exchange or task descriptions, but it does not automatically solve delegation, scheduling, ownership, timeout management, conflict resolution, or result verification. Those are runtime concerns.
In short: protocols define how components communicate; the runtime determines how those interactions participate in an executable workflow.
6. The Environment Deserves an Explicit Place
An agent does not act in an abstract space made only of prompts, memory, and tools. It acts in an environment: filesystems, browsers, databases, APIs, shells, development environments, and external services.
It is useful to separate the concepts involved:
| Concept | Responsibility |
|---|---|
| Skill | Packages a reusable procedure or capability |
| Tool | Exposes an operation that can be invoked |
| Protocol | Defines the interaction contract |
| Runtime | Coordinates and controls execution |
| Environment | Hosts resources and produces observable effects |
For example, a browser tool is an interface for interacting with a browser environment. A database connector exposes operations against a database; it is not the database itself. A sandbox is an execution environment that the runtime may provision, not a skill. The original diagram shows sandbox provisioning as a harness utility, but it does not give the sandboxed environment an explicit place.
Making the environment explicit improves reasoning about isolation, permissions, side effects, reproducibility, and recovery.
7. Governance Is Cross-Cutting
The original diagram includes normative constraints under Skills and an approval loop within Harness. Both are relevant, but neither is a sufficient home for governance. A skill can declare task-specific constraints, and the runtime can enforce them; system-wide policy, however, must remain authoritative independently of any individual skill or model-generated guidance.
Security, identity, authorization, policy, audit, and human approval affect multiple stages of execution:
- Which skills may be loaded?
- Which memories may be retrieved?
- Which models and endpoints may be used?
- Which tools may be invoked?
- Which resources may be read or modified?
- Which actions require human approval?
- Which outputs may be returned or persisted?
Governance is therefore best represented as a cross-cutting responsibility. The runtime provides enforcement points, while policy ownership, identity, audit, and organizational controls may be implemented in separate services or infrastructure.
8. A Runtime-Centric Reference Architecture
These distinctions lead to a more coherent architecture. The following decomposition organizes the system by responsibility rather than treating every concept as a peer component.
The proposed architecture still has four outer domains—skills, memory, environment, and protocols. The difference is that they are arranged around a runtime rather than presented as four equivalent categories.
8.1 Interaction layer
Defines interfaces, communication contracts, and event sources:
- User interaction
- Agent-to-agent communication
- Tool interaction protocols
- Events and external triggers
8.2 Agent runtime / Harness
Coordinates the execution lifecycle:
- Goal intake and task initialization
- Scheduling and plan execution
- Context assembly
- Tool dispatch
- Sub-agent coordination
- State transition management
- Feedback processing
- Timeouts, cancellation, retries, and idempotency
- Checkpointing and resumption
8.3 Cognitive layer
Provides reasoning and decision functions:
- LLM inference
- Reasoning
- Decision-making
- Task decomposition and plan generation
8.4 Capability layer
Provides reusable and executable capabilities:
- Skills
- Tools
- Sub-agents
- Retrieval
- Code execution
8.5 State and memory layer
Provides durable state and reusable information:
- Durable operational state
- Episodic memory
- Semantic knowledge
- Procedural memory
- User and project profiles
The runtime owns state transitions; this layer owns the durable record those transitions operate on.
8.6 Environment layer
Provides the resources and systems with which the agent interacts:
- Filesystem
- Browser
- Databases
- Network and APIs
- Compute and sandbox infrastructure
- External services
Cross-cutting governance and quality
Applies across the architecture:
- Security and identity
- Access control
- Policy and compliance
- Human approval
- Observability and audit
- Evaluation and quality assurance
- Reliability and recovery policy
These functions set policy, standards, and audit requirements; the runtime implements the corresponding mechanisms. The layers are logical, not a mandate to deploy a separate service for each one. A small agent may implement several responsibilities in one process. A larger platform may distribute them across services. The purpose of the decomposition is to make ownership, interfaces, and invariants explicit—not to prescribe a deployment topology.
9. Why This Model Is More Useful for Engineering
A runtime-centric approach offers several practical advantages.
Model independence. Separating inference from runtime orchestration allows the system to change models or inference providers without redesigning task management, tool execution, and recovery.
Explicit failure semantics. Timeouts, cancellation, retries, idempotency, checkpointing, and resumption have clear architectural owners. They do not depend on the model remembering what happened.
Reliable state management. Operational state remains distinct from retrieved memory and prompt context. Context can be compressed or reconstructed without silently becoming the source of truth.
Composable capabilities. Skills and tools can evolve behind stable interfaces while orchestration, authorization, and observability remain consistent—making the system easier to maintain.
Enforceable security boundaries. Policy checks can be applied at relevant execution points. A model-generated tool request is a proposal, not proof of authorization.
Scalable multi-agent coordination. Delegation, concurrency, ownership, result aggregation, timeout handling, and failure propagation become explicit runtime responsibilities rather than being mistaken for protocol features.
10. A Fair Assessment of the Original Diagram
The criticism deserves precision. If the original diagram is intended as an introductory concept map, its four categories are useful: they remind readers that agents need capabilities, memory, execution control, and communication mechanisms.
The problem arises when the diagram is treated as a reference architecture. Its categories mix different levels of abstraction, the execution loop remains implicit, operational state is absent, Working Context is treated as a kind of memory, and the environment is not given an explicit layer.
A better architecture does not need to discard the original concepts. It needs to reorganize them around their actual responsibilities and relationships.
The four concepts still matter:
- Skills belong to the capability model.
- Memory belongs to the retained-information model; operational state belongs to the runtime.
- Protocols belong to the interaction model.
- Harness is the runtime and control layer.
They are all essential, but they do not occupy equivalent architectural positions.
Conclusion: Design Around Execution, Not Around a Collection of Components
The original diagram captures an important truth: a production-grade agent is much more than an LLM with tools. But its four-part classification is better understood as a conceptual checklist than as a rigorous system architecture.
For engineering, the more useful starting point is the execution lifecycle. The runtime coordinates inference, context, capabilities, state, protocols, and the environment. It manages actions and observations, preserves execution state, enforces policy, evaluates results, and supports recovery.
Memory should distinguish operational state from persistent knowledge. Skills should be treated as reusable capabilities. Protocols should be treated as communication contracts. The environment should be explicit. Governance should cross architectural boundaries.
The central question is therefore not simply “What components should an LLM agent have?” It is:
“How do we build a runtime that allows an intelligent system to pursue objectives over time, preserve state correctly, act within defined boundaries, use observations to adjust its behavior, and recover from failure?”
That is the harder engineering problem—and the reason a Runtime-Centric Agent Architecture is a stronger foundation for reliable, scalable, and maintainable agent systems.

Top comments (0)