Arquitectura y runtime de AI Agent Harness

En los sistemas de IA en producción, el Harness (andamio de ejecución y runtime del agente) representa el chasis de sistema operativo que transforma LLMs fundamentales en ejecutores autónomos de tareas del mundo real.

Production Agent = Frontier LLM (Brain) + Domain Skills (SOPs) + Robust Harness (Execution Chassis)

🔗 Agent Skills · Claude Code · LLM & Agent Concepts · Always-on Agents

---

1. Comparación: LLM base frente a agente con Harness

flowchart LR
  subgraph Bare ["Bare LLM (Stateless Brain)"]
    direction TB
    P1["User Prompt"] --> M1["Raw LLM Weights"]
    M1 --> O1["Static Text / Code Block
(Cannot Run, Cannot Verify)"]
  end

  subgraph Harnessed ["Harnessed Agentic System"]
    direction TB
    P2["High-Level Goal"] --> H1["Context Assembler"]
    H1 --> M2["LLM Planner"]
    M2 --> E1["Sandboxed Execution Engine
(Bash, File System, MCP)"]
    E1 --> V1["Verification & Error Feedback Loop"]
    V1 -- "Tests Fail (Reflect & Retry)" --> H1
    V1 -- "Tests Pass" --> O2["Production Ready Deliverable
(Git Commit / Verified PR)"]
  end

  style Bare fill:#fef2f2,stroke:#f87171,stroke-width:1px;
  style Harnessed fill:#f0fdf4,stroke:#22c55e,stroke-width:2px;

---

2. Los seis pilares fundamentales de un Agent Harness industrial

1. Dynamic Context Engineering (Input Layer)

• Token Budget Manager: Dynamically allocates context tokens across system prompts, conversation history, project trees, and active file buffers.
• Hierarchical Context Compaction: Automatically trims verbose tool returns, converts stack traces into concise signatures, and maintains sliding summaries.
• Project Awareness Anchors: Ingests project-level metadata (CLAUDE.md, .cursorrules, repository tree, active git status) into the initial system prompt.

2. Sandboxed Tool Execution Engine (Action Layer)

• Containerized Isolation: Runs bash commands inside lightweight container environments (Docker, Podman, gVisor) or isolated host subshells.
• Deterministic File Primitives: Dedicated hunk-based diff editors and structured file search tools (grep, glob, AST parsing) rather than brittle line overwrites.
• Model Context Protocol (MCP): Standardized dynamic discovery and protocol binding for databases, dev tools, and external APIs.

3. Verification & Guardrail Engine (Feedback Layer)

• Automated Test Runners: Executes unit and integration test suites automatically after code modifications.
• Output Validation: Validates compiler and linter diagnostics before declaring completion.
• Destructive Action Gates: Blocks catastrophic shell commands (rm -rf /, DROP TABLE, uncommitted hard resets) and requests explicit human confirmation.

4. Working Memory & Scratchpad (State Layer)

• Working Scratchpad: A dedicated markdown buffer or persistent scratchpad file where the agent drafts step-by-step plans, hypotheses, and diagnostic traces.
• Checkpoint & Rollback Manager: Records git branch commits or filesystem snapshots prior to multi-file refactoring passes.

5. Multi-Agent Delegation & Swarms (Collaboration Layer)

• Hierarchical Orchestration: The lead planner agent spawns specialized subagents (e.g., Code Researcher, Database Specialist) with scoped permissions.
• Baton-Passing Loops: Independent subagents execute bounded assignments in isolated workspaces and return structured summaries to the orchestrator.

6. Observability & Telemetry (Operations Layer)

• Structured Trace Logging: Records full token costs, model latency, tool invocation parameters, and exit codes into queryable JSONL transcripts.
• Cost & Loop Quotas: Hard circuit-breakers preventing runaway infinite reasoning loops and catastrophic API token consumption.

---

3. Flujo cerrado de resolución de bugs en 10 pasos (SWE-bench)

---

4. Componentes centrales del sistema dentro de un Harness

┌──────────────────────────────────────────────────────────────┐
│                    Harness Runtime Core                      │
├──────────────────────────────┬───────────────────────────────┤
│ Context Engine               │ Execution Engine              │
│ - CLAUDE.md / Rules Loader   │ - Sandboxed Shell (gVisor/OS) │
│ - Token Budget Allocator     │ - Hunk-based Diff Editor      │
│ - Transcripts / Summarizer   │ - Model Context Protocol (MCP)│
├──────────────────────────────┼───────────────────────────────┤
│ Verification & Guardrails    │ Memory & State Store          │
│ - Test Runner & Parser       │ - Scratchpad & Checkpointer   │
│ - Human Approval Gateway     │ - Local Symbol / Ctags Cache  │
│ - Cost & Loop Limiters       │ - Trace Logger (JSONL)        │
└──────────────────────────────┴───────────────────────────────┘

---

5. Comparativa de implementaciones industriales de Harness

---

6. Cinco reglas de oro de la ingeniería de Harness

Rule 1: Optimize the Agent-Computer Interface (ACI)
        Standard UNIX tools are designed for humans. Agent tools must return structured,
        noise-free outputs with clear error signatures and line numbers.

Rule 2: Never Let Context Become the Bottleneck
        Compress verbose tool outputs aggressively. Truncate long build logs to the relevant
        compiler warnings and the final 20 lines of stack traces.

Rule 3: Enforce Small, Verifiable Iteration Loops
        Discourage the agent from making massive multi-file changes in a single turn. Enforce
        an edit-test-verify cycle on each atomic change.

Rule 4: Provide Checkpoints and Fast Rollbacks
        If an agent introduces a cascading syntax regression, rolling back via git checkout
        is far cheaper and more reliable than prompting the model to untangle its own mistakes.

Rule 5: Build Explicit Guardrails Around Destructive Actions
        Enforce strict permission gates for out-of-sandbox writes, network requests, and
        irreversible database commands. Safe environments enable higher autonomy.