Closed-Loop Agent Control Beats Frontier Models

closed-loop-agent-control.md

Date Compiled: 2026-05-30

title: Closed-Loop Agent Control Beats Frontier Models

Source

Nikita M. (@meln1k), May 29 2026:

last night I was testing 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". my setup was the following: deepseek-v4-flash (opencode-go sub btw), bevy (rust game engine), and pi coding agent. The goal was to build a flappy bird clone first, then add a space-invaders like mechanic where the bird shoots lasers from its eyes. I did some small scaffolding, and added a pi extension that had 3 tools: getState, adjustClock and sendInput. The tools talked to a json http endpoint embedded in the game binary. The agent could read the important game state, adjust the clock so game logic advanced in lockstep with its reasoning, and send inputs to control the game. I have to say that because the game time was a first-class knob for the agent, it turned into a unbelievably strong way of closing the feedback loop. The agent was running the game, adjusting the json output endpoint, discovering bugs and quickly iterating. I would say it is much much more effective than using a frontier model but monitoring the output myself and giving the agent directions based on the observed results. So the practical learning from the experiment: do whatever you can, but close the damn loop.

Key Insight

A smaller model with a tight, automated feedback loop outperforms a stronger model that depends on human observation and direction.

The critical variable isn't model capability — it's loop closure speed. When the agent can observe state, act, and observe results without human intermediation, iteration speed goes from minutes (human watches output, types feedback) to seconds (agent reads state, acts, reads again).

The Setup

Model: DeepSeek V4 Flash (via opencode-go)
Game engine: Bevy (Rust)
Coding agent: Pi coding agent
Task: Build Flappy Bird, then add space-invaders laser mechanic

Architecture

Three tools exposed to the agent via a Pi extension:

Tool	Function
`getState`	Read game state from embedded JSON HTTP endpoint
`adjustClock`	Advance game logic in lockstep with agent reasoning
`sendInput`	Send player inputs to control the game

The JSON HTTP endpoint was embedded in the game binary — no separate server process needed.

Why It Worked

Game time as a first-class knob — adjustClock let the agent control when game logic ticked, turning async observation into synchronous debugging. The agent could pause, step, and inspect at will.

Zero-latency feedback — No human in the loop. Agent acts → reads state → acts again. Iteration cycle: seconds, not minutes.

State visibility — getState gave the agent structured access to everything happening in the game, not just visual output.

Low-cost model, high-quality loop — DeepSeek V4 Flash is cheap. The loop infrastructure made up for any model capability gap vs. a frontier model.

Implications for Agent Architecture

Close the loop before upgrading the model. A $0.10/M-token model with perfect feedback beats a $15/M-token model with human-in-the-loop observation.
Embed observability in the target system. JSON endpoints, structured state输出, programmatic access — not screenshots or logs that need human interpretation.
Time control is underappreciated. Letting the agent control execution pace (pause, step, fast-forward) is a superpower for debugging and iteration.
Tool design > model selection. The three tools (read state, control time, send input) were simple but precisely what was needed. Tool design is an architectural decision, not an afterthought.