Closed-Loop Agent Control — The Feedback Loop Trumps Model Size

Type: Experimental pattern
Source: Nikita M. (@meln1k) — 2026-05-29
Related: simon-w-agentic-engineering-patterns, operator-control-patterns, kelly-handbook-ch7-multi-agent

The Hypothesis

"If I give the agent the right tools and close the feedback loop, even a smaller model with a closed loop can outperform a stronger model that relies on human-observed feedback."

This is a direct challenge to the assumption that model quality is the primary determinant of agent performance. Nikita's experiment isolates one variable: feedback loop completeness.

The Setup

Component Detail
Model DeepSeek V4 Flash (opencode-go sub)
Game engine Bevy (Rust)
Coding agent Pi coding agent
Task Build Flappy Bird, then add a space-invaders shooting mechanic

The scaffolding was minimal. The key addition was a Pi extension with three tools:

  1. getState — reads the current game state via a JSON HTTP endpoint embedded in the binary
  2. adjustClock — advances the game clock so game logic runs in lockstep with agent reasoning
  3. sendInput — sends inputs to control the game (flap, shoot)

Why This Matters

The tools form a complete sensory-motor loop for the agent:

  • Perception: getState gives the agent a structured view of the world
  • Action: sendInput lets the agent act on the world
  • Control: adjustClock lets the agent decide when the world advances

This is fundamentally different from a human watching a screen and telling the agent what to do. The agent is inside the loop, not observing from outside.

The Result

"Because the game time was a first-class knob for the agent, it turned into an unbelievably strong way of closing the feedback loop."

The agent ran the game, adjusted the output endpoint, discovered bugs, and iterated — all autonomously. Nikita's assessment: "much much more effective than using a frontier model but monitoring the output myself and giving the agent directions based on the observed results."

Why It Works: Three Mechanisms

1. Latency Collapse

Human-in-the-loop feedback has inherent latency: agent produces output → human observes → human interprets → human articulates feedback → agent receives feedback. Each step introduces delay and information loss.

With tools, the loop is: agent acts → state updates → agent reads state. The latency is bounded only by the tool call roundtrip, not by human reaction time.

2. Information Fidelity

Human feedback is lossy. "The bird hit the ceiling" loses information about velocity, position, timing, and all other state variables. getState returns the complete, structured game state — no interpretation needed.

3. Temporal Control

The adjustClock tool is the most novel element. By letting the agent control game time, it can:

  • Advance frame-by-frame for precise debugging
  • Skip ahead to test specific scenarios
  • Pause to reason about state
  • Replay interactions to verify fixes

This transforms the agent from a passive observer into an active experimenter.

Implications for Agent Architecture

The Real Lesson

"Do whatever you can, but close the damn loop."

This echoes a broader pattern in agentic systems: tooling quality matters more than model quality past a certain threshold. A mediocre model with excellent tools and tight feedback will outperform a brilliant model operating through a human intermediary.

Design Principles

  1. Give agents structured state access — not screenshots, not logs, structured data they can parse programmatically
  2. Let agents control execution flow — clock control, pause/resume, step-through
  3. Minimize the observation-to-action cycle — every tool call should return immediately actionable information
  4. Embed the endpoint in the target system — not a sidecar, not a proxy, the actual binary

Connection to Existing Patterns

This experiment validates several existing patterns in the factory:

  • operator-control-patterns — the factory's Operator Hold/Queue mechanisms are a human-in-the-loop version of the same principle. Nikita's experiment shows what happens when you replace the human with tools.
  • simon-w-agentic-engineering-patterns — Simon Willison's patterns emphasize giving agents clear feedback mechanisms. Nikita's experiment quantifies the payoff.
  • kelly-handbook-ch7-multi-agent — multi-agent systems benefit from closed loops even more, since coordination overhead compounds with each open loop.

Open Questions

  • Does this generalize beyond games? Games have deterministic, machine-readable state. Can the same approach work for web apps, APIs, or business processes?
  • What's the minimum viable toolset? Nikita used 3 tools. Would 2 suffice? Would 5 be better?
  • How does this interact with model capability? At what model quality does the loop advantage disappear? Would GPT-5 with a closed loop still beat DeepSeek V4 Flash with one?

Bibliography

Concept Cross-References