---
type: claim
domain: ai-alignment
secondary_domains: [collective-intelligence]
description: "Code-to-text migration study on OSWorld shows NLAH realization (47.2%) exceeded native code harness (30.4%) while relocating reliability from screen repair to artifact-backed closure — NL carries harness logic when deterministic operations stay in code"
confidence: experimental
source: "Pan et al. 'Natural-Language Agent Harnesses', arXiv:2603.25723, March 2026. Table 5, RQ3 migration analysis. OSWorld (36 samples), GPT-5.4, Codex CLI."
created: 2026-03-31
depends_on:
- harness engineering emerges as the primary agent capability determinant because the runtime orchestration layer not the token state determines what agents can do
- the determinism boundary separates guaranteed agent behavior from probabilistic compliance because hooks enforce structurally while instructions degrade under context load
- notes function as executable skills for AI agents because loading a well-titled claim into context enables reasoning the agent could not perform without it
related:
- harness module effects concentrate on a small solved frontier rather than shifting benchmarks uniformly because most tasks are robust to control logic changes and meaningful differences come from boundary cases that flip under changed structure
- file-backed durable state is the most consistently positive harness module across task types because externalizing state to path-addressable artifacts survives context truncation delegation and restart
reweave_edges:
- harness module effects concentrate on a small solved frontier rather than shifting benchmarks uniformly because most tasks are robust to control logic changes and meaningful differences come from boundary cases that flip under changed structure|related|2026-04-03
- file-backed durable state is the most consistently positive harness module across task types because externalizing state to path-addressable artifacts survives context truncation delegation and restart|related|2026-04-17
---

# Harness pattern logic is portable as natural language without degradation when backed by a shared intelligent runtime because the design-pattern layer is separable from low-level execution hooks

Pan et al. (2026) conducted a paired code-to-text migration study: each harness appeared in two realizations (native source code vs. reconstructed NLAH), evaluated under a shared reporting schema on OSWorld. The migrated NLAH realization reached 47.2% task success versus 30.4% for the native OS-Symphony code harness.

The scientific claim is not that NL is superior to code. The paper explicitly states that natural language carries editable, inspectable *orchestration logic*, while code remains responsible for deterministic operations, tool interfaces, and sandbox enforcement. The claim is about separability: the harness design-pattern layer (roles, contracts, stage structure, state semantics, failure taxonomy) can be externalized as a natural-language object without degrading performance, provided a shared runtime handles execution semantics.

The migration effect is behavioral, not just numerical. Native OS-Symphony externalizes control as a screenshot-grounded repair loop: verify previous step, inspect current screen, choose next GUI action, retry locally on errors. Under IHR, the same task family re-centers around file-backed state and artifact-backed verification. Runs materialize task files, ledgers, and explicit artifacts, and switch more readily from brittle GUI repair to file, shell, or package-level operations when those provide a stronger completion certificate.

Retained migrated traces are denser (58.5 total logged events vs 18.2 unique commands in native traces) but the density reflects observability and recovery scaffolding, not more task actions. The runtime preserves started/completed pairs, bookkeeping, and explicit artifact handling that native code harnesses handle implicitly.

This result supports the determinism boundary framework: the boundary between what should be NL (high-level orchestration, editable by humans) and what should be code (deterministic hooks, tool adapters, sandbox enforcement) is a real architectural cut point, and making it explicit improves both portability and performance.

## Challenges

The 47.2 vs 30.4 comparison is on 36 OSWorld samples — small enough that individual task variance could explain some of the gap. The native harness (OS-Symphony) may not be fully optimized for the Codex/IHR backend; some of the NLAH advantage could come from better fit to the specific runtime rather than from portability per se. The authors acknowledge that some harness mechanisms cannot be recovered faithfully from text when they rely on hidden service-side state or training-induced behaviors.

---

Relevant Notes:
- [[harness engineering emerges as the primary agent capability determinant because the runtime orchestration layer not the token state determines what agents can do]] — this paper provides direct evidence: the same runtime with different harness representations produces different behavioral signatures, confirming the harness layer is real and separable
- [[the determinism boundary separates guaranteed agent behavior from probabilistic compliance because hooks enforce structurally while instructions degrade under context load]] — the NLAH architecture explicitly implements this boundary: NL carries pattern logic (probabilistic, editable), adapters and scripts carry deterministic hooks (guaranteed, code-based)
- [[notes function as executable skills for AI agents because loading a well-titled claim into context enables reasoning the agent could not perform without it]] — NLAHs are a formal version of this: natural-language objects that carry executable control logic

Topics:
- [[_map]]