Back to all writing

Field notes

The Code Review That Never Started

On a VanillaCore Agent Harness with the background dispatcher enabled, large changes were rejected before the review worker started, because the review request hit a 64,000-character limit meant for ordinary tasks. Core PR #193 raised that input limit to 1 MiB this morning. A local run shows the difference, and the two-minute deadline on the default review path is still in place.

The Code Review That Never Started

My agent harness will not finish a code-changing turn until a separate reviewer has examined the exact change and the review gate has approved it. Until a fix merged this morning, on an installation with the background dispatcher switched on, that review could fail before the review worker even started. Every request that carries the diff to that worker was checked against a limit of 64,000 characters, and a larger change was rejected at the door. The gate correctly granted no approval, and according to the pull request that fixed it, the only trace was a generic message saying the reviewer had failed.

I want a review gate that fails closed, and this one did. A gate that blocks for a reason nobody can see is still a problem, though, because the next person who hits it starts looking for a way around it. Core pull request #193, merged at 07:33 this morning, raises that input limit to 1 MiB and gives the review worker 30 minutes instead of two. I think the fix is right, and its interesting part is what it leaves alone.

Cover image: an overstuffed white envelope with a muted blue strip across its flap sticks out of the narrow slot of a small dark graphite box on a navy desk. Text above it reads: Harness review rejected big diffs before its worker even started. Input limit raised to 1 MiB.

Where 64,000 characters came from

Mandatory review runs as its own job in the VanillaCore Agent Harness. It captures the diff of the working tree against a base, wraps it into a review prompt and hands that prompt to an isolated, tool-free model session. When the background dispatcher is enabled, which is an explicit operator setting and off by default, the prompt travels as a task through a durable execution ledger of its own, built from the same ledger code I described in The VanillaCore Agent Harness Now Keeps a Ledger of Its Own Work. That code validates every submission, and until #193 it rejected any task input longer than 64,000 characters.

That limit made sense for what the ledger was built for, which is ordinary agent tasks with a short instruction. A review task is different, because its input embeds the full diff, escaped as JSON, where every line break becomes two characters. Diff capture has its own fail-closed limit of 512 KiB, so the transport limit was the narrower one by a wide margin. The PR author reports that on the running 0.1.120 instance, review rounds on real changesets failed instantly, with no worker session and no entry in the worker ledger, only the generic reviewer-failure text in the round.

The code has a second chance built in: when the primary path fails, the review plugin hands the same request to a fallback, a fresh review session on a snapshot of the working tree. Why that fallback did not rescue those rounds is not in the PR, and I did not reproduce that part. What the review documentation does say is that a failed call grants no approval and consumes one reserved review round. With the default of three rounds, three failed rounds on a large change end with the review escalated to the operator, who then has to decide about a change that no reviewer approved.

What a scripted run shows

To see the limit as behavior, the AI agent that drafts these changelog posts built a review prompt with the Harness's own prompt builder from two real diffs of the core repository, v0.1.120 to v0.1.121 and v0.1.121 to v0.1.125, and sent each one through the real dedicated review worker class, once at v0.1.124 and once at v0.1.125. The model was a scripted fake that answered with an empty findings list, the ledger ran on local files, and the run called the worker directly, without the plugin and its fallback, so this is a controlled local run, not a live agent.

Review submission v0.1.124 v0.1.125
One release, 16,748 characters reviewed reviewed
This night, 77,960 characters rejected reviewed

That second row is the night described in this post. Every single pull request in it fits under the old limit, the largest at about 37,000 characters, but the whole night as one change does not. On v0.1.124 the worker rejected it with "Invalid execution submission" before the fake model was called once. On v0.1.125 the same request reached the model with its 75,871-character prompt intact. #193 ships a regression test that behaves the same way: it fails on v0.1.124 with the same error, and at the merge it passes together with the 14 tests already in that file.

What still has two minutes

#193 covers one path. It raises the submission limit and moves the dispatcher worker's deadline from 120 seconds to 30 minutes, because, according to the code comment, local flash providers took between 70 and more than 600 seconds for the same review prompt of about 38 KiB. Both other paths kept their old deadline. With the dispatcher off, which is the default, review runs in a dedicated subagent that still requests cancellation after 120 seconds. And the fallback that takes over when the primary path fails, a review handed over with a snapshot of the working tree, also still requests cancellation after 120 seconds.

I would not call that an oversight, but it is the next limit someone will hit. A slow local model that needs four minutes for a large diff now gets its answer through the dispatcher worker and loses it on the default path. The 1 MiB limit also has an edge: it covers the 512 KiB capture limit for an ordinary diff, but a diff made mostly of characters that JSON must escape can still grow past it, and then the submission fails closed as before. Result, checkpoint and reply fields in the ledger stay at 64,000 characters.

Recovery checks that could not decide

A second behavior change came earlier in the night. Core #194, merged at 22:15, changes what happens when the Harness restarts with a task that was still open and has no saved next step. A separate assessment decides whether that task is done, waiting, blocked or should continue, and failed assessments get three attempts. Before #194, an assessment that answered honestly that it could not tell used up one of those attempts, exactly like a crashed call. Now the Harness separates the two cases. A technical failure or an invalid answer still uses an attempt and is retried, while a valid "uncertain" blocks the task right away with a notice that says the assessment was undecided, that this is not a technical error and that it does not confirm a real blocker. When the task has a stored last reply, the notice now also carries it, marked as unverified evidence.

Again, the AI agent that drafts these posts ran the four test files #194 adds or changes against the release before it, v0.1.123, where 3 of 24 tests pass and 21 fail, and at the merge, v0.1.124, where all 24 pass. These are local tests with fake sessions, not a live system. The PR states its own limit plainly: many distinct uncertain tasks can still produce many notices, and this is not a fix for recovery notification noise in general.

The rest of the night

Core #188 and plugins #31 let an agent name the stored task its continuation plan belongs to, instead of always attaching it to the current task. The selection must resolve to an eligible task in the same session, cannot extend that task's deadline, and on a core that does not support the selection the plugin fails closed. Core #191 replaces a history-dependent compatibility test for that change with a fixed fixture and changes no production code. Core #190 is documentation only: it records that the dispatcher routing rules and the model list for reasoning effort "none" can be changed in the local settings overlay without a restart.

What merged and what shipped

All times are Europe/Berlin. The window runs from 20:00 on Saturday, 31 October, to 08:00 on Sunday, 1 November 2026, and covers the three public repositories the harness organization listed when checked: core, deployment-base and plugins. Core merged five pull requests between 20:45 and 07:33, plugins merged #31 at 20:32, and deployment-base merged nothing.

Core published four release tags in the window. Resolving them to commits shows v0.1.122 at the merge of #191 (containing #188 and, through the plugin pin, plugins #31), v0.1.123 at the merge of #190, v0.1.124 at the merge of #194 and v0.1.125 at the merge of #193, published at 07:39. A release tag is not a running agent, so this post makes no claim about which installation runs any of this.

Where this lands

So the review gate did what a gate should do with a request it could not handle: it refused and granted nothing. Its defect was that the refusal looked like a reviewer failure while the review worker had never started, and that the limit behind it was sized for a different job. #193 fixes the size problem for the dispatcher path and leaves the two-minute deadline on the default path in place, so the next failure on a large change is already visible in the code, and I would rather fix that one before somebody finds it with a real change.

Sources used