These are my notes on harness engineering. I wanted to clarify what happens outside the model: how a task starts, who executes action requests, how results enter the next call, and how work continues after an interruption.
Tool calling lets a model request actions. Turning those requests into a task that keeps moving requires a program to organize context, connect the execution environment, maintain state, and provide ways to check results. These arrangements directly affect what an agent can accomplish and the cost of doing so.
The first five chapters introduce general harness responsibilities, execution loops, long-task recovery, and feedback mechanisms. Chapter 6 then examines how specific projects implement them. If you are working through this layer too, I hope you will read along and share your understanding and practical experience.
1 Why a Harness Is Needed: From Model Calls to Task Execution
Beyond the model: turning one response into ongoing work
A model call takes input and generates output. That output can be an answer or a tool request containing a name and arguments. A program still needs to parse the latter, find its implementation, check execution conditions, and send it into a real environment. Generating call arguments does not complete the corresponding operation.
After a tool finishes, the program must collect observations, update current state, and decide whether to make another model request. A task may also need to wait for user input, pause an operation, or stop at a limit. Connecting these handoffs produces an agent capable of sustained action.
An Agent Harness usually refers to the surrounding runtime system that lets a model operate as an agent. Anthropic’s guide to agent evaluation describes it as the system that processes inputs, organizes tool calls, and returns results. The model provides decision-making capabilities; the harness places those decisions into an executable process. Both affect task performance.
How the concepts relate: models, prompts, tools, and harnesses
| Object | Main responsibility | Relationship to the harness |
|---|---|---|
| Model | Generates answers, action requests, or other output from input | Provides reasoning and decision-making capabilities |
| Prompt | Expresses goals, constraints, background, and ways of working | Part of model input, organized and supplied by the runtime system |
| Tool calling | Expresses actions as requests a program can process and receives results | An interface between the model and external capabilities |
| Framework / SDK | Provides reusable capabilities such as model adapters, tools, state, and orchestration | Can be used to build a harness or may already include a usable loop |
| Agent Harness | Organizes input, loops, tool execution, state, and feedback | Lets the model advance tasks in a specific environment |
| Evaluation Harness | Runs evaluation tasks, records execution, scores, and aggregates results | Evaluates the combination of model and runtime system |
These objects overlap in products. An SDK can encapsulate a complete tool loop, while an application can maintain workspaces, task progress, and recovery outside that SDK. Their relationship depends on actual responsibilities rather than project names alone.
A prompt instruction such as “inspect before editing” can guide model choices, but the program still determines tool availability, argument validity, and the identity and environment under which an operation executes. Natural-language conventions and execution constraints serve different purposes and need to work together.
Scope: from a minimal loop to a task runtime system
A short task may need only a model, a few tools, and a loop. More state persistence, environment management, and result verification become necessary when tasks span contexts, depend on external services, or require handoffs between people.
Planners, subagents, long-term memory, and independent evaluators can help particular tasks without becoming mandatory components of every harness. Building effective agents likewise emphasizes starting with simple, composable patterns and adding complexity according to task benefits.
Harness engineering in a broader sense also includes the working environment: whether project knowledge can be found, dependencies installed, applications started, and errors and artifacts inspected. The runtime organizes actions, while the environment determines what feedback those actions can produce.
2 Overall Architecture: Connecting Control, Execution, State, and Feedback
Logical components: assigning responsibilities around a task
A harness can first be understood through its logical responsibilities. The model interface connects to inference services, runtime control schedules what happens next, context assembly determines current input, the tool system connects actual capabilities, and session state preserves interactions that have occurred. These connect in turn to storage, workspaces, and external services.

Original logical diagram: runtime responsibilities are inside the boundary, with models, storage, and execution environments outside. Policies connect as needed. Lines represent interfaces rather than a fixed call sequence or separate deployments.
| Responsibility | Receives | Produces |
|---|---|---|
| Runtime control | New input, current state, model responses, and execution status | Next actions, waiting, pauses, or termination |
| Context assembly | Task requirements, instructions, relevant material, and historical observations | Messages and tool descriptions visible to the model in this call |
| Model adaptation | Assembled requests and call configuration | Answers, tool requests, streaming fragments, and usage |
| Tool routing and execution | Tool names, arguments, execution policies, and environment information | Results, errors, or status associated with the call |
| Session and state management | Accepted input, model output, calls, and results | State readable by later loops and records that can be saved |
| Observation and result checking | Runtime records, actual artifacts, and task criteria | Feedback for the next call, evidence of completion, and diagnostic information |
This table explains responsibilities. An implementation can place several in one module or separate them. Logical divisions do not require each responsibility to run as an independent service.
Control and observation: who chooses actions and who schedules execution
The model chooses tools or generates answers from current input, and runtime control handles those outputs. It decides how to dispatch a batch of calls, which may run in parallel, when to accept new user input, and when to request the model again.
Tool results form the observation path back. File contents, query results, and command errors enter the next context after preparation, giving the model a basis for adjusting its actions. Progress depends on this connection in both directions.
“The model chooses the next step” and “the program schedules the next step” can therefore both be true. The former proposes actions; the latter enforces scheduling, execution conditions, and runtime boundaries. Waiting for a long task, rejecting an unauthorized operation, or stopping an over-budget run can all be handled by the program.
Context and state: turning saved information into current input
A runtime system generally holds more state than one model request can accommodate. Session records may contain complete tool outputs, old messages, and runtime events, while current input needs the portions relevant to the task.
Context assembly maintains goals, valid constraints, current progress, and key observations. It also decides what to add through retrieval or on-demand reading. Large results can stay in files, and tool catalogs can be reduced for the current task. Retained references must remain readable.
Context is what the model sees in this call, session state is the program’s record, and the real environment holds actual work artifacts. They need to correspond: a recorded file modification should exist in the workspace, and a summary declaring an item complete should lead to its supporting evidence.
Execution environments: aligning capabilities, permissions, and work targets
A tool name describes only an interface. The actual operation may occur in a local process, container, remote sandbox, or external service. Working directories, dependencies, networking, and credentials affect what the same request produces.
File tools and command tools also need to target the same work. If one modifies a local directory while another checks a different container, the observation may not reflect the action just taken. The runtime needs explicit path mappings, artifact persistence, and environment lifecycles.
Permissions must be enforced at actual execution points. Tool availability, argument checks, operation authorization, and operating-system isolation address different problems. A local subprocess sandbox does not automatically constrain a remote service, and permission to make a call does not allow it to exceed the environment’s own access restrictions.
3 The Execution Loop: Sending Action Requests into the Environment and Returning Observations
The main loop: from input to observation, then deciding whether to continue
One user input can trigger several model calls. The model obtains material and requests actions, then analyzes tool results until the task requirements are satisfied or conditions require waiting, pausing, or stopping.
Building effective agents describes these agents as loops that keep using tools in response to environmental feedback. The following task-adjustable pseudocode illustrates the main handoffs rather than a particular SDK’s API:
state = load_or_create_task(input)
while limits.allow_next_step(state):
request = assemble_context(state)
response = call_model(request)
state.record_response(response)
if response.tool_calls:
results = executor.run(response.tool_calls, policy, environment)
state.record_tool_results(results)
continue
check = check_completion(state, environment)
if check.complete:
return finish(check.evidence)
if check.can_continue:
state.add_observation(check.feedback)
continue
return pause(check.reason, state)
return stop_with_reason_and_state("limit_reached", state)This code highlights the relationships among model, tools, state, and completion checks. Input queues, streaming display, cancellation, and saving policies can connect at the corresponding boundaries, and the tool executor may have its own scheduling. Implementations use turn, step, and run differently; reading one requires establishing which span of work each term denotes.
Ending a model response and completing an entire task need separate judgments. Completion checks can use tool results, deterministic rules, or necessary human judgment; they do not require an additional evaluator-model call every round.
Action handoffs: sending tool requests into a real environment
Tool descriptions supplied to the model usually contain names, purposes, and argument structures. The host separately holds execution functions, routes, and policies. After the model generates a request, the program finds its implementation through registration, validates arguments, and confirms current execution conditions.
A batch of requests is not necessarily suitable for simultaneous execution. Independent queries can run in parallel, while actions depending on earlier results must preserve order. Concurrent changes to the same work target also require conflict handling. What tools declare permissible and what a scheduler actually arranges are separate layers.
Each call needs an association with its result. The program can retain a call identifier, arguments, and start and end states, then organize results as required by the model interface. Even refusals and errors should inform the next call how the request was handled.
For example, after a command returns “file not found,” the next call should be able to inspect the directory or path. Returning only an empty string leaves the model unable to tell whether execution started and without a basis for adjustment, making repeated requests more likely.
Returning results: what the next step needs to know
Raw tool output can differ from the observation the model needs. Commands may produce long logs and searches may return many documents. The runtime can keep complete results while returning relevant passages, summaries, status, and references for rereading.
Summaries should preserve errors and conditions that affect decisions. Truncation should also be recognizable, or the model may treat partial output as complete. File modifications can include the changed range and ways to check it, enabling inspection of actual artifacts in the next step.
Streaming fragments, tool execution status, and final results also need to remain distinct. An interface can show progress first while the record layer saves complete or partial output according to implementation rules. Displaying some text does not necessarily mean the task has ended or that the text can survive process recovery.
Runtime boundaries: how errors, cancellation, and budgets affect the loop
Different failures need different feedback. Invalid arguments may require a revised call, permission refusals require respecting execution scope, and business failures require checking task conditions. Recoverable faults such as temporary network errors can be retried according to the operation’s characteristics. Retry safety also depends on whether it may have produced unconfirmed side effects.
Cancellation requests need to reach actual execution. Tools supporting cooperative cancellation must check or forward signals; processes and remote tasks may need their own stop interfaces. After requesting cancellation, the system still needs to confirm whether execution stopped and whether it had already made changes.
Budgets also operate at different levels: a tool timeout controls one action, an overall deadline limits the task, and call or cost limits bound accumulated consumption. At a limit, the system should preserve necessary state, return the stopping reason, and explain existing results. Waiting for information, cancellation, exhausted budgets, and successful completion should have distinguishable ending states.
4 Long Tasks and Recovery: Saving Progress, Resuming Execution, and Reconciling Results
What to save: context, sessions, progress, and actual artifacts
Once a task spans contexts or processes, the first question is what to save. One system can manage several kinds of objects, but each restores something different:
| Object | Main contents saved | What it helps establish during recovery |
|---|---|---|
| Current context and summaries | Key messages, material, goals, and constraints | Background needed for the next inference call |
| Session events and runtime state | Inputs, calls, results, pending items, and execution position | How far the record extends and which handoffs remain unfinished |
| Task progress and verification evidence | Completed, incomplete, and unchecked items with evidence | What to do next and whether task requirements are satisfied |
| Work artifacts and external state | Files, databases, service records, and environmental changes | Whether actual work exists and what its current result is |
A summary can help a new context understand a task, but cannot preserve a destroyed file system. Session recovery can reconstruct interactions without establishing that the workspace and external services remain in the same state.
A recovery claim therefore needs to specify its object. Continuing conversation, retrieving task progress, retaining files, and reconnecting to a still-running process are different capabilities that cannot be summarized by one resume button.
Progress handoffs: showing the next stage where to continue
Long tasks need saved goals, current progress, unresolved questions, and checkable evidence. Handoffs should point to actual material such as file locations, diffs, check results, or external record identifiers, allowing the next execution to confirm the state rather than rely only on earlier prose. Tasks with an overall budget should also save consumption alongside progress.
Anthropic’s long-task practices use feature lists, progress files, Git, and item-by-item verification to support work across sessions. These help a new context quickly understand the state, choose a specific objective, and leave artifacts that support later continuation.
Different tasks can use different organizations. A short task does not necessarily need a separate initialization role, a uniform file format, or commits at every step. Saved information should serve actual handoffs rather than let record maintenance displace the main work.
Saving policies: recovery promises depend on when saving happens
In-memory state serves the current process; surviving process exit also requires persistence. Even after a write interface is called, the storage backend determines when saving is confirmed and what an interruption may lose.
Save timing can follow task boundaries. For example, record intent and stable identifiers before important actions, save results afterward, and save progress before a handoff. Implementations may use event logs, state snapshots, or both. Save frequency affects performance and the extent of recovery.
LangGraph’s persistence guide also distinguishes runtime state within a thread from stored material across threads and explicitly notes that in-memory savers cannot retain state across process restarts. Mechanisms differ, but recovery promises still depend on the saved objects, backend, and timing.

Original relationship diagram: runtime state, persistent records, and actual artifacts preserve different things. The diagram shows a checking path after an action is recorded but its result is missing. Specific save timing depends on the implementation and its recovery promises.
Missing results: checking real state before continuing
A critical gap lies between an action and recording its result: a request is recorded, a tool may have changed the environment, and the system stops before saving the result. A missing local result after recovery means only that the outcome is unconfirmed; it does not establish that the operation never happened.
Recovery must read records first, then inspect the workspace or external service. File changes can be checked through current content and diffs, and remote operations can be queried using stable identifiers. Confirmed success, confirmed failure, and continuing uncertainty should lead to different next steps.
LangGraph’s explanation of retry boundaries notes that reexecuting a node does not automatically give its side effects exactly-once guarantees. An idempotency identifier has deduplication value only when it is stable, reconstructible from saved state, and actually supported by the executor.
When neither querying nor reliable deduplication is available, resubmitting directly may increase uncertainty. The action can be paused, retaining known facts and missing information before deciding how to proceed. Recovery first aims to reestablish trustworthy task state; continuing the loop follows from that.
5 Feedback and Evaluation: Judging Completion and Improving the Runtime System
Three feedback paths: observation, checking, and offline comparison
Tool results first serve current execution: the model reads errors, search results, or file changes and decides what to do next. At task completion, artifacts must also be checked against requirements. Comparing harness designs requires a separate set of repeatable tasks and evaluation conditions.

Original relationship diagram: tool observations support decisions in the current loop, real outcomes are checked against task requirements, and offline evaluation compares system performance. An independent grader is not a mandatory step in every tool call.
| Path | Main inputs | Question it addresses |
|---|---|---|
| Execution feedback | Tool observations, errors, and verification findings | How should the next step change? |
| Task-result checking | Actual artifacts or environmental state and task criteria | Did this attempt satisfy the requirements? |
| Offline evaluation | Task set, environment, model and harness, and scoring rules | Did a change improve performance under specified conditions? |
Anthropic’s evaluation guide distinguishes transcript/trace from outcome: the trace records interactions during execution, while the outcome is the actual environmental result at the end of a trial. A tool returning success, a model claiming completion, and a final result meeting requirements need separate checks.
Observation records: locating failures at handoffs
Records should connect the same work: which input triggered a model request, which tool calls its response produced, what their results were, and what artifacts remained. Task, request, and call identifiers can link these handoffs. Arguments, status, duration, and usage then help locate problems.
Real-time events, persistent records, and actual results serve different purposes. Progress events support the interface, session records support inspection and recovery, and artifact checks establish whether work was actually completed. These can be linked without replacing one another.
Following these records reveals whether input was accepted, what the model saw, whether a tool truly started, and whether results were returned. This makes it easier to distinguish a wrong model action from an inconsistent execution environment or a lost result at a handoff.
For large outputs and sensitive material, retention should be designed around diagnostic needs with suitable references and access methods. Recording complete interactions also does not mean observing all of a model’s internal reasoning.
Evaluation conditions: separating outcomes, constraints, and resources
To compare a change, first fix tasks, models, tools, environments, and budgets, then observe what changes. Correctness, constraint adherence, duration, and cost are different dimensions; they need not be compressed into an unexplained aggregate score.
Code assertions suit conditions with clear judgments. Open-ended quality can use model judges, but both the criteria and judges need calibration. Where variability is substantial, an appropriate number of trials can show the distribution. Failures from actual use can also become evaluation material over time rather than relying on one successful demonstration.
Evaluation rules should allow different valid paths. Requiring a specific tool-call sequence may reject a correct outcome, while checking only a final answer may miss environmental errors. Process constraints and outcome checks should be selected separately according to task requirements.
Engineering environments: enabling agents to discover and verify problems
Feedback comes from more than conversation records. An agent struggles to verify its actions when the application cannot start, logs are unreadable, or project conventions are hidden where they cannot be retrieved.
Ryan Lopopolo’s Harness engineering discusses making repository knowledge discoverable, applications runnable, and logs, metrics, and interfaces inspectable by agents. These facilities provide actual verification entry points, while tools and checks can turn rules into executable constraints.
Failures can guide component additions. If information is missed, inspect inputs and tool results first. If work state is lost, examine saving and recovery. If the model has the right material but still misjudges completion, investigate stopping conditions and result verification.
Anthropic’s harness-design experiment also records removing components: as model capabilities changed, some context resets and phase organization became less necessary, and independent evaluators’ benefits varied with task difficulty. Planning, subagents, repeated evaluation, and extra services should each provide actual value, with call, waiting, and maintenance costs included.
6 Implementation Observations: Turning General Responsibilities into Specific Projects
DeepSeek Harness: combining plugins, loops, and sessions into a runtime system
DeepSeek Harness, or dsh, is DeepSeek’s official Agent Harness project. It uses Cordis plugins to combine model adapters, tools, sessions, and the default loop. The preceding responsibilities can be traced through its public interfaces, actual driver, and saving policies.
Module composition: separating public interfaces from the default driver
The dsh architecture guide assigns major responsibilities to separate packages:
| Module | Runtime responsibility | Interface |
|---|---|---|
core/session | Append-only session events and in-memory session access | ctx.sessions |
core/system-prompt | Assembly of prompt sections and the current step’s tool schemas | ctx.systemPrompt |
core/tools | Scoped tool registration, executor selection, and execution-policy integration | ctx.tools |
core/agent | Public Agent interface, run-instance registry, and runtime events | ctx.agents |
core/agent-loop | Default driver implementing the public interface | ctx.agentLoop |
llm/llm | Model messages, streaming responses, and adapter interfaces | ctx.llm |
Cordis lets plugins contribute services, event listeners, and revocable registrations to shared context. agent specifies how outside components interact with run instances, while agent-loop provides the default driver. The tool registry manages capabilities and scopes, and executors handle call batches.
This composition supports extending or replacing implementations while retaining public contracts. Packages and plugins express code responsibilities without requiring separate process deployments.
One advancement: passing input through models and tools
The default driver starts with pending input, determines the current model and tools available for the step, assembles the prompt, and passes through step control and request preparation. Accepted input enters the session record, and deriveMessages() projects model history from the log. The current request is then fixed before streaming begins. Default loop source
After the response is finalized according to the recording semantics, any tool calls go to the selected executor for batch processing and result recording. Tool observations and pending input jointly affect continuation. A dsh turn contains zero or more steps; rejected input, for example, can produce a turn without model advancement.
The host’s tool definitions contain execution functions and result-processing callbacks, while the registry separately manages scope. Schemas supplied to the model project only information needed to select tools and generate arguments. The model requests calls, and the host executes them using registration data. Tool registry source
The tool pipeline: connecting policies, execution, and results
dsh’s built-in executor handles raw-batch parsing, scheduling, cancellation, and session accounting for calls and results. Each call then passes through a shared tool pipeline:

Source: DeepSeek-AI, Tool Execution Pipeline, MIT license. Re-rendered from the complete official Mermaid source with nodes and connections unchanged. The diagram shows the call pipeline used by this project’s built-in executor.
Following the main path, tool/call is created before tool execution, and pre-execution policies handle allowance, refusal, or confirmation requirements. Non-relaxable guards remain after preprocessing: confirming a call once cannot bypass these refusal conditions. tools/execute provides a place to wrap actual execution.
Tool results pass through content preparation, postprocessing, and final content constraints. Relevant exception branches normalize failures into error results. After tools/result observes the final result, a model-visible session tool/result is created. Interface cards update through a side path, and their completion state still needs to be judged separately from business results.
The file-write intent check in the diagram applies only to the relevant file tools. Custom executors do not automatically inherit every policy in the built-in pipeline. Replacing an implementation requires establishing who handles call accounting, result processing, and cancellation. Rewriting a result after execution does not undo an external operation that has already taken effect.
Session saving: attaching backends and checkpoint policies separately
In dsh, appending in memory, a storage backend accepting an append, and waiting for the flush persistence barrier are different promises. Session events preserve session facts, while real-time agent/* events and capability-extension events have other purposes. Receiving a notification cannot be taken as confirmation of persistence. Session Persistence
Persistence backends and save timing are configured separately. With the corresponding checkpoint policy enabled, listeners wait for the recorded request prefix to become persistent before a model request actually starts, save the corresponding call before top-level tool dispatch, and save previously committed results at the next step boundary. Checkpoint policy source
If saving fails at the relevant boundary, execution does not proceed to the downstream adapter or tool body. Nested tool calls reuse the persisted outer call record. This does not mean every nested action is independently saved synchronously to disk.
Interruption handling: stream finalization, unknown outcomes, and cancellation
dsh separates incremental streams during execution from final accounting. Finalized responses or failed attempts enter the corresponding records. If a process is abruptly lost before finalization, displayed fragments may not have become recoverable persistent records. Lifecycle guide
When interrupted logs are repaired, tool calls missing results receive TOOL_OUTCOME_UNKNOWN, preserving an unconfirmed gap. This does not establish that a tool never ran. External state still needs checking rather than unconditional retries.
Cancellation uses cooperative signals that tools must respond to or forward. A cancellation request cannot forcibly stop arbitrary in-process code and does not roll back external changes already made. Session logs, execution policies, and the real environment each retain their own responsibilities. Together, these boundaries determine the recovery capabilities dsh can actually provide.
Codex: a runtime core serving different clients
Codex’s public runtime core organizes model calls, tool execution, history, and rollout persistence. App Server supplies a client protocol around it, letting different interfaces initiate work and receive progress, tool events, and interaction requests. Official harness architecture guide
It uses thread, turn, and item for different interaction levels: a thread contains conversation history, a turn represents a round of work, and an item represents specific content or execution. One user input can produce many tool calls and events, so interactions between clients and the core are richer than a single question and answer. App Server protocol
This example helps examine the division between clients and a runtime core. The public repository’s core and interfaces can be studied directly, while capabilities of the full desktop or hosted products need separate confirmation. Restoring conversation history also does not imply restoration of exited system processes or external side effects.
Claude Code: combining product loops, permissions, and file rewind
Claude Code’s working model describes gathering context, acting, and verifying. Tasks do not need the same fixed number of cycles, and tool observations affect subsequent actions. The surrounding harness provides tools and manages what the model can see.
It also saves conversation messages and tool interactions, supporting continuation and forking. Context compression changes later model input, while session records provide a basis for continued inspection. Permission rules and operating-system sandboxes constrain execution at different levels, with actual behavior depending on the selected mode and configuration. Permissions
Checkpointing further distinguishes code rewind from conversation rewind. File restoration has its own tracking scope. Files changed only through Bash and not tracked by file tools, as well as subagent or external changes, need handling under their corresponding conditions. This shows how a product helps users correct work, but does not imply transactional rollback of arbitrary commands, databases, and remote services.
Pi Agent: leaving extension space around a minimal core
Pi’s toolchain separates model adapters, an Agent core, and a coding product with sessions. pi-ai handles different model interfaces, pi-agent-core manages loops and tools, and pi-coding-agent organizes interaction, sessions, and context. Project packages
The core loop receives model responses, the host executes tools, and toolResult enters context. Tool results or queued input can drive later requests. Events for run, turn, message, and tool execution let external components observe and integrate with execution. Agent core
Input queues have explicit timing. Steering enters after the current assistant turn and its tool calls complete; follow-up enters after current work ends naturally. New messages therefore do not immediately reverse side effects already produced.
Pi sessions form trees from JSONL entries with id and parentId. The active branch participates in later input, while original records remain after compression. Branch operations in Sessions manage conversation paths. File restoration can be implemented through extensions and needs separate confirmation.
A minimal core also leaves some execution policies for users to compose. Tools and in-process extensions use the launching process’s permissions by default. Project trust primarily constrains resource loading and does not establish sandbox isolation for files, processes, networking, or credentials. Security, Extensions
Hermes Agent: connecting multiple entry points and later experience to the loop
Nous Research’s Hermes Agent connects the CLI, messaging gateway, and other entry points to an Agent core. The entry layer normalizes requests, routes sessions, and delivers results, while the loop organizes model requests, tool rounds, text finalization, and related control. Architecture
Tool dispatch is separate from execution backends. Terminal capabilities can connect to local, Docker, SSH, or cloud environments. Isolation, file persistence, and process survival depend on the backend. A persistent file system does not guarantee that a live sandbox or long-running process survives exit cleanup. Tools and backends
Sessions store messages and metadata in SQLite, with FTS5 for history retrieval. An input already in progress may become unknown after its execution owner is lost. That outcome gap needs handling before any assumption that side effects can be replayed. Session Storage
Hermes also uses file memory, history retrieval, and Skills for later tasks: it saves facts and methods from interactions for on-demand reading, revision, and reuse. These mechanisms update external material such as memory and skills. They do not mean Hermes trains model weights during use by default. Memory, Skills
When reading these implementations, keep following the same questions: where current input comes from, who executes actions, which records have been saved, what observations the next call sees, and how final task outcomes are confirmed. Tracing these handoffs makes the relationship between model capabilities and real work clearer.

