We rebuilt our harness from scratch

The short version

We started with Pogl Builder, which used OpenCode, a proven open-source coding agent, as it was. Over time we added many features of our own, it was heavy to run in a virtual sandbox, and legacy features piled up until it became inefficient.
Our new harness, Pogl Agent, runs consulting, planning, building and editing on one loop, 13 tools, one contract and one conversation history per experience. We rolled it out to half of our users on November 11.
When we scored 54 pairs of the same requests by the same standard, quality was about the same. In 8 requests the new harness fixed everything the old one had left unfinished, and in 5 it was the other way around. Per edit, the uncached input the model reads fell 65% on average and its output fell 52%, and jobs that ran for more than 40 minutes disappeared.

At Pogl, AI talks with people to build and edit experiences. We call the framework that does this work the harness. On November 9, we decided to rebuild it from scratch.

We started with OpenCode

OpenCode is an open-source coding agent used by many developers. It was already widely used and proven, and it came with what we needed: reading and editing files, switching models and connecting other tools. So we used OpenCode as the agent and added our own tools for launching and checking games, plus pre-release checks, on top. That was Pogl Builder.

Three things stopped fitting

We ended up adding many features of our own. Choosing models, tracking costs and switching providers during outages moved into a middle layer we built, and the tools and checks were ours from the start. By November, OpenCode was handling little more than the read-and-edit loop.

It had to run in a virtual sandbox, not on a personal computer. OpenCode is a tool for a developer’s own machine. At Pogl we started a virtual machine for every job, installed an OpenCode server (about 0.63 GB) inside it, and the worker kept polling until a result came back. The fixed part sent at the start of every request was about 14,000 tokens. Its size and performance needed to fit this environment.

Legacy features piled up and made it inefficient. New features were added as new paths outside OpenCode. As of November 9 there were 16 branches depending on the kind of request, 3 ways of judging whether a job was done and 6 to 7 contract documents for the AI, and the engine of a feature we had already removed from the app was still in the harness. The same problem had to be fixed separately on each path, and restarting the worker cut off jobs in progress.

Pogl Builder (Legacy) until November 9. Each kind of request had its own path and contract document, and there were three ways of judging whether a job was done.

The better the models, the simpler the harness had to be

Recent posts and research from other companies pointed the same way: as models get stronger, complex structures built into a harness get in the way more than they help.

Lovable built a complex design that handed work to subagents, then deleted almost all of its agent code. (How we built Lovable, November 2026)
Replit says every model release makes assumptions built into the harness go stale, so it leaves decisions to the model and keeps only options and guardrails in the harness. (Free the models, September 2026)
Cursor separated the agent loop, the machine state and the conversation history. (What we’ve learned building cloud agents, June 2026)
Apple researchers reported that with the same model and the same time, complex harnesses did no better than a simple agent. (How Much of a Harness Does a Strong Agent Need?, October 2026)

So we rebuilt the loop, tools, contract and conversation history, the parts that define how the AI works, from scratch. The rules for money, refunds and checks came from real incidents, so we carried them over from the old code as they were.

Pogl Agent runs on one loop

The new harness is called Pogl Agent. Requests from consulting, planning, building, editing, error fixing and external AI tools all go into the same loop. The loop asks the model, runs the tool the model picked, and records the result, over and over. The core loop is 715 lines.

Pogl Agent. Every request goes through one conversation history per experience into the same loop, and the platform runs the final check and judgment in one place.

Five things changed.

There are 13 tools, registered in one place. Reading files, editing, clicking through the game in a browser, making images and sounds, and viewing earlier versions are all in one list. The edit tool only changes code when there is exactly one place to change. All tool descriptions together fit within 3,000 tokens, and long material such as the voice list moved into documents that are read only when needed.
One generator writes the contract. It looks at whether the game is single-player or multiplayer, 2D or 3D, and writes the document for the AI at that moment.
Each experience has one conversation history. Even after a long consultation, what was decided stays in the same history when an edit is sent. Messages sent while a job is running go into the same history too.
Every step leaves one line in the log. When the worker restarts, it rebuilds the conversation from this log and continues. It does not start over.
The loop calls the model directly. There is no server in between, and the rules for which model to use and when to switch providers during an outage live in one place inside the loop.

The step of installing an OpenCode server in the virtual machine is gone too. Virtual machines are now used only to launch and check games.

The heaviest jobs went away

The fixed part at the start of every request went from 14,000 tokens to under 6,000. Material that is needed only occasionally, such as the voice list, moved into documents that are read only when needed.

We compared edits applied in the same window starting at 12:59 a.m. KST on November 11. Per edit, the input the model read without cache fell from an average of 195,000 tokens to 69,000, and the output the model wrote fell from an average of 21,000 tokens to 10,000.

Tokens per edit (from 12:59 a.m. KST on November 11, average of 25 applied edits each). Bar lengths are scaled to Pogl Builder in each row.

Most of this difference came from a few very large jobs on the old harness. Before, a handful of jobs read hundreds of thousands of new tokens and ran for over 40 minutes. The new harness had none. Looking only at typical jobs, the new harness read less new input, but it re-read more from cache, wrote more output and took longer.

We reran the same requests

On November 10 we resent past edit requests, unchanged, to 60 copies of real experiences. We then re-scored the results of both harnesses with the same judge, because the two harnesses judge by different standards and their own verdicts could not be compared directly. We compared the 54 pairs where judging finished.

54 pairs of the same edit requests re-scored by the same judge (November 10, per requested item).

Overall rates were similar, but there were differences request by request. In 8 requests, the new harness resolved every item the old harness had left as “not done” or “needs checking.” In 5 requests it was the other way around.

What changed was how results were reported. We reran an edit that had come in through a creator’s support request. The old harness had marked an unfixed item as “done” and charged credits. The new harness opened the version history, found the version that caused the problem, concluded there was no way to restore it, marked it “not done” and refunded all the credits.

We rolled it out to half of our users

At 12:59 a.m. KST on November 11, we turned on Pogl Agent for half of our users. We split by person, so no one meets one harness while consulting and another while editing. If something goes wrong, a single setting sends everyone back to Pogl Builder within a minute.

In the first two hours, 17 of 20 edits were applied. In one, the AI concluded it could not fix the request and refunded the credits; one had nothing to change; and one was stopped by the user. No job ended in failure. 44 consultations were handled normally.

Time taken was distributed differently.

Time taken by edits applied in the same window from 12:59 a.m. KST on November 11 (Pogl Builder 17, Pogl Agent 25).

On the old harness, half of the jobs finished within 6 minutes, but some took 25, 27, 42 and 53 minutes. On the new harness, every job finished in 7 to 31 minutes. Small requests taking more than 7 minutes came from the AI running checks too often, so early on November 11 we changed it to check less often, and we are measuring the effect.

There is now one place to fix

The biggest change in this work is the number of places to fix. Before, the same problem had to be fixed separately on each path. Now the loop, tools, contract and judgment are in one place. Most problems we found during the comparison and the half rollout were fixed in one place the same day.

We will roll it out to the other half in steps, then remove the Pogl Builder and OpenCode code.