The Cybernetic Governor: Guides, Sensors & Feedback Loops

---

1. Classical Cybernetics Applied to Autonomous Agents

In 1948, Norbert Wiener defined cybernetics as "the scientific study of control and communication in the animal and the machine." In 1956, W. Ross Ashby formulated the Law of Requisite Variety:

                           ┌─────────────────────────┐
                           │      DESIRED STATE      │
                           │ (System Specifications) │
                           └────────────┬────────────┘
                                        │
                         ┌──────────────▼─────────────┐
                         │   CYBERNETIC CONTROLLER    │
                         │    (Harness Logic Plane)   │
                         └──────┬─────────────▲───────┘
           Feed-Forward Control │             │ Feedback Control
           (Guides & Priors)    │             │ (Sensor Diagnostics)
                                ▼             │
                         ┌─────────────┐      │
                 ┌──────►│  LLM AGENT  ├──────┴──────────┐
                 │       └──────┬──────┘                 │
                 │              │                        │
                 │              │ Generates Patch        │
                 │              ▼                        │
                 │       ┌─────────────┐                 │
                 │       │ REPOSITORY  │                 │
                 │       │ ENVIRONMENT │                 │
                 │       └──────┬──────┘                 │
                 │              │                        │
                 │              ▼                        │
                 │       ┌─────────────┐                 │
                 │       │   SENSORS   │                 │
                 └───────┤  (Feedback) ├─────────────────┘
                         └─────────────┘

When an LLM coding agent interacts with a production codebase: 1. The Codebase is a High-Variety Dynamic System: Thousands of files, transitive dependencies, runtime states, concurrency hazards, and architectural conventions. 2. The LLM is an Unbounded Variety Generator: A probabilistic model can output millions of syntactically valid but architecturally catastrophic variations of code. 3. The Harness as the Governor: Without a harness operating as a cybernetic regulator, the variety of errors will overwhelm human review bandwidth.

---

2. The Hashimoto Loop: Mistake → Permanent Control

In February 2026, Mitchell Hashimoto formulated the fundamental continuous-improvement protocol for harness engineers:

$$\text{Agent Mistake} \xrightarrow{\quad\text{Root-Cause Analysis}\quad} \text{Permanent Deterministic Control}$$

                           THE HASHIMOTO LOOP

┌─────────────────────────┐
│ Agent Commits a Mistake │ (e.g., modifies deprecated API, introduces circular import)
└───────────┬─────────────┘
            │
            ▼
┌─────────────────────────┐
│ Human Intervenes        │ (DO NOT simply re-prompt: "Please don't do that")
└───────────┬─────────────┘
            │
            ▼
┌─────────────────────────┐
│ Engineer a Permanent    │ • AST Linter (disallows specific import pattern)
│ Deterministic Control   │ • Pre-commit test sensor (verifies boundary)
└───────────┬─────────────┘ • Sandbox restriction (chroot/path lock)
            │
            ▼
┌─────────────────────────┐
│ Automated Verification  │ The specific failure mode can NEVER recur,
└─────────────────────────┘ regardless of which model is used in the future.

The Anti-Pattern: Prompt Pleading

• Prompt Pleading: Telling an agent, "Remember to never use library X because it causes memory leaks." This works stochastically for a few turns, then fails when context rolls over.
• Deterministic Walls: Writing an ESLint/Ruff rule or Semgrep query that errors on import X. The model hits a hard compiler wall and is forced to use the approved alternative.

---

3. The Dual-Control Architecture: Guides vs. Sensors

As established by Thoughtworks and Birgitta Böckeler on martinfowler.com, an agent harness functions through two interconnected control vectors:

┌─────────────────────────────────────────────────────────────────────────────┐
│                       THE CYBERNETIC CONTROL DUALITY                        │
├──────────────────────────────────────┬──────────────────────────────────────┤
│               GUIDES                 │               SENSORS                │
│        (Feed-Forward Control)        │          (Feedback Control)          │
├──────────────────────────────────────┼──────────────────────────────────────┤
│ • Operates BEFORE code generation    │ • Operates AFTER code generation     │
│ • Constrains the action space        │ • Measures state delta and deviation │
│ • Prevents obvious errors upfront    │ • Provides closed-loop correction    │
│ • Optimizes token and compute cost   │ • Guarantees deterministic safety    │
│                                      │                                      │
│ Examples:                            │ Examples:                            │
│ - AGENTS.md / CLAUDE.md guidelines   │ - Unit and integration test suites   │
│ - Rigid schema contracts (JSON/YAML) │ - Fast static linters (Ruff, ESLint) │
│ - ArchUnit directory boundaries      │ - Type-checkers (tsc, mypy)          │
│ - Modular Dev-Primitives (HERMES)    │ - Build and compiler diagnostics     │
│ - Pre-flight branch rules            │ - Dynamic sandbox runtime inspectors │
└──────────────────────────────────────┴──────────────────────────────────────┘

---

4. Software Factory Architecture: Inner, Outer & Meta Loops

Research by Tessl and autonomous software engineering labs categorizes agent harness execution into three nested concentric loops:

                       THE THREE CONCENTRIC LOOPS

 ┌────────────────────────────────────────────────────────────────────────┐
 │                              META LOOP                                 │
 │   Harness Optimization: Auto-tuning tools, synthesizing linters,       │
 │   evaluating failure distributions, evolutionary harness evolution.    │
 │ ┌────────────────────────────────────────────────────────────────────┐ │
 │ │                           OUTER LOOP                               │ │
 │ │   Software Factory: Task planning, branch creation, PR drafting,   │ │
 │ │   integration test execution, human review gates, deployment.      │ │
 │ │ ┌────────────────────────────────────────────────────────────────┐ │ │
 │ │ │                         INNER LOOP                             │ │ │
 │ │ │   Code Generation: Model generation ◄══► Sub-5s Sensor         │ │ │
 │ │ │   (Type check, AST linter, Test Impact Analysis unit tests).   │ │ │
 │ │ └────────────────────────────────────────────────────────────────┘ │ │
 │ └────────────────────────────────────────────────────────────────────┘ │
 └────────────────────────────────────────────────────────────────────────┘

1. The Inner Loop (Turn-Level): High-frequency, sub-5-second self-correction cycles. Model emits a patch $\to$ AST syntax check runs $\to$ scoped unit test executes $\to$ structured diagnostic returns.
2. The Outer Loop (Task-Level): Task lifecycle management. Decomposes user issue into sub-tasks, assigns git worktrees, runs full regression suites, generates PR descriptions, and awaits human governance sign-off.
3. The Meta Loop (System-Level): Continuous harness optimization. Evaluates across thousands of historical runs: which tools cause timeouts? Which prompts trigger hallucinations? Uses evolutionary search or reinforcement learning to refine the harness itself (e.g., Test-Time Harness Evolution - TTHE).

---

5. Model-Agnostic Harnesses

A world-class harness is decoupled from specific model weights. By treating the model as a modular reasoning plugin across standardized interfaces (such as Anthropic, OpenAI, or Ollama APIs): * Model Arbitrage: Routing routine boilerplate generation to lightweight, low-cost models (e.g., Qwen 2.5 Coder, Claude 3.5 Haiku) while reserving frontier models (e.g., Claude 3.5 Sonnet, OpenAI o3) for complex multi-file architectural reasoning. * Instant Upgradability: When a superior foundation model is released, the organization swaps an environment variable without re-engineering sandboxes, test sensors, or permission gates.

---

6. The Core Trade-offs of Harness Design

                     THE COST–QUALITY–SPEED TRILEMMA

                                 QUALITY
                              (Correctness)
                                   ▲
                                  ╱ ╲
                                 ╱   ╲
                                ╱     ╲
                               ╱       ╲
                              ╱         ╲
                             ╱           ╲
                            ▼─────────────▼
                         SPEED              COST
                    (Cycle Latency)   (Inference & Token $)

Harness architects navigate three fundamental trade-offs: 1. Capability vs. Control: Highly constrained harnesses (e.g., Agentless sequential pipelines) guarantee compliance and prevent runaway spending, but struggle with open-ended exploratory research. Highly autonomous agent loops (OpenHands) possess high exploration capability, but risk context drift and infinite retries. 2. The Cost–Quality–Speed Trilemma: * High Quality + High Speed = High Cost (running parallel frontier models with extensive Test Impact Analysis). * High Quality + Low Cost = Low Speed (running multi-turn iterative repair with smaller models and thorough verification suites). 3. Harness–Model Co-Evolution: As models become more capable, certain low-level harness scaffolding (e.g., basic syntax repair) can be retired, while higher-level harness governance (e.g., multi-agent synchronization and architectural consistency) becomes increasingly vital.

---

7. The Cybernetic Loop in Code

Below is an architectural implementation of a production cybernetic harness:

class CyberneticHarness:
    def __init__(self, model, guides, sensors, sandbox, logger):
        self.model = model
        self.guides = guides
        self.sensors = sensors
        self.sandbox = sandbox
        self.logger = logger

    def execute_task(self, task_spec, max_iterations=5):
        # 1. FEED-FORWARD: Build context conditioned on Guides
        context = self.guides.compile_context(task_spec)

        for iteration in range(max_iterations):
            # 2. INFERENCE: Model proposes patch
            patch = self.model.generate_patch(context)

            # 3. ACTUATION: Apply patch inside isolated worktree
            with self.sandbox.ephemeral_worktree() as worktree:
                worktree.apply_patch(patch)

                # 4. FEEDBACK: Evaluate state against cascading Sensors
                sensor_report = self.sensors.evaluate(worktree)

                if sensor_report.all_passed:
                    worktree.commit(f"feat: resolved {task_spec.id}")
                    return {"status": "SUCCESS", "iterations": iteration + 1}

                # 5. CYBERNETIC STEERING: Format sensor diagnostics back to ACI
                context.append_sensor_feedback(
                    sensor_report.to_agent_computer_interface()
                )
                self.logger.record_turn(iteration, sensor_report)

        # 6. HASHIMOTO LOOP TRIGGER: Unresolved failure triggers control review
        self.logger.flag_for_permanent_control(task_spec, sensor_report)
        raise ConvergenceFailure("Agent failed to satisfy cybernetic sensors.")

---

8. References & Further Reading

1. Hashimoto, Mitchell (February 5, 2026). "My AI Adoption Journey".
2. Böckeler, Birgitta (Thoughtworks / martinfowler.com, April 2026). "Harness engineering for coding agent users".
3. Tessl Research (2025–2026). "The Autonomous Software Factory: Inner, Outer, and Meta Loops".
4. Ashby, W. Ross (1956). An Introduction to Cybernetics. Chapman & Hall.
5. Wiener, Norbert (1948). Cybernetics: Or Control and Communication in the Animal and the Machine. MIT Press.