Glossary

The runtime infrastructure around a language model that decides what enters context, dispatches tools, persists state, and captures trajectories. Not the model. Not the prompt. The code that drives both.

Meng et al.'s formal definition. A harness is the six-tuple of Execution loop, Tool registry, Context manager, State store, Lifecycle hooks, and Evaluation interface.

The observe–think–act–commit cycle. Sequences turns, terminates cleanly, recovers from errors. Necessary for any system to count as a harness.

The typed catalog of tools. Validates schemas before dispatch; routes to implementations; mediates between the model's tool calls and the implementations that do the work.

The component that decides what enters the model's context window each turn. Compaction, retrieval, ordering. Most of what "context engineering" described in 2025 lives here.

What survives across turns. Files on disk, git history, vector stores, structured memory. Externalized state that doesn't depend on the model holding it in context.

Pre- and post-call interception points. Auth, audit, policy, redaction, metrics. The component most underbuilt in real systems.

Standardized capture of action trajectories, intermediate states, and success signals. What downstream consumers (benchmarks, optimizers, analyzers) read directly. Not the same as logging.

One revolution of the execution loop: observe → think → act → commit. The unit of execution and the unit of trajectory capture.

Summarizing earlier conversation in place so the same agent continues with shortened history. Preserves continuity. Doesn't eliminate context anxiety.

Clearing the context window entirely; a fresh agent rebuilds from on-disk handoff artifacts. Eliminates context anxiety; makes the handoff the main correctness surface.

Behavior where a model wraps up work prematurely as it approaches what it believes is its context limit. Model-dependent. Mostly absent on Opus 4.6+.

Two prompts over one harness. The initializer writes durable artifacts (feature list, progress file, init script, initial commit); the coding agent reads them at session start, picks one feature, verifies, commits, and updates progress.

GAN-inspired pattern. The generator writes; the evaluator drives the live artifact, grades it against a contract, and emits findings. Tuning the evaluator to be skeptical is much easier than tuning the generator to be self-critical.

A small file written before code generation that specifies what "done" looks like. Shared input to generator and evaluator. The tiebreaker when they disagree.

A structured natural-language artifact that exposes a harness's control logic: contracts, roles, stages, adapters, state semantics, failure taxonomy. Consumed by a shared runtime (IHR) so harnesses become editable, comparable, and migratable.

A harness whose task is designing other harnesses. A coding-agent proposer reads logs and traces from prior runs and proposes new harness code. Empirically beats hand-engineered baselines.

AHE's three-pillar realization of V and L. Component observability = file-backed loosely-coupled harness pieces. Experience = layered drill-downable trace corpus. Decision = versioned change manifest with falsifiable predictions.

The asymmetry where a self-improving harness can predict what an edit will fix (~5× chance) far more reliably than what it will break (~2× chance). Named in AHE as the clearest direction for future self-evolution loops.

A failure mode where local verifier success diverges from the benchmark's actual acceptance criterion. Adding more structure can move acceptance signals away from benchmark acceptance. Mitigation: align verifier criteria to path-addressable artifacts the benchmark itself reads.

The 2026 successor discipline to prompt and context engineering. Designing the full six-component runtime, not just the prompt or the context. Coined by OpenAI in February 2026.

The move of cognitive burden out of model weights into runtime artifacts: memory, skills, protocols, and the harness that coordinates them. Frames why "harness-only" wins are real: the harness changes what the model has to solve internally. (source: 2604.externalization-llm-agents.pdf, §1)

The three externalization dimensions the harness coordinates. Memory externalizes state across time (working, episodic, semantic). Skills externalize procedural expertise (reusable, loadable procedures, e.g. CLAUDE.md, named skills). Protocols externalize interaction structure (typed tool schemas, MCP, lifecycle contracts). All three compete for the same context budget and must be routed together. (source: 2604.externalization-llm-agents.pdf, §3-§5)

The boundary where model output becomes executable reasoning, a programmable action, or inspectable environment state. A typed tool call is one example; a generated test, plan file, or verifier is another. (source: 2605.code-as-harness.pdf, §2)

A control loop that binds every accepted state transition to three things: an externalized plan contract (intent, invariants, acceptance criteria, rollback), execution in a sandboxed permissioned environment, and verification that emits a structured evidence bundle. Generalizes generator-evaluator and initializer + coding agent into one operational state machine. (source: 2605.code-as-harness.pdf, §3.4)

A layered set of checks (syntax/types, unit behavior, properties, static risk, runtime evidence, formal constraints, human judgment) where each layer declares what it verifies and what it misses. Pass is evidence, not truth. Action verifiers and AutoHarness are narrow verification stacks. (source: 2605.code-as-harness.pdf, §5.2.2)

A code-level legality predicate that filters illegal or unsafe actions before they reach the environment. AutoHarness is the extreme case where the harness collapses to one such predicate. Generalizes to permission gates, edit guards, and command allowlists. (source: 2603.autoharness.pdf; 2605.code-as-harness.pdf, §2.2 and §3.3)

An abstraction for multi-agent code work where each action declares its read set, write set, assumptions, verifier obligations, and conflict policy. Catches semantic conflicts (stale plans, obsolete invariants, divergent assumptions) that text-merge tools miss. (source: 2605.code-as-harness.pdf, §5.2.4)

Human approval represented as harness state rather than a one-shot prompt. Carries action, evidence, scope, decision, expiration, and a consumption log so later calls can be checked against the original grant. Prevents approval laundering, scope creep, and untracked denial. (source: 2605.code-as-harness.pdf, §5.2.5)