The G Training Center: A Null Baseline for an Agent Persona

A Cloudflare build was taking the better part of an hour. The change waiting on it was a text file: the persona that tells G how to behave. Nothing about editing a paragraph justifies a 45-minute wait to find out whether the paragraph worked, and yet the loop was set by the compiler rather than by the size of the edit.

That mismatch is the whole origin. When the feedback loop is slower than the thought, you stop running the experiment you actually wanted and start running the one you can afford, which is a quiet way to stop measuring anything. The Training Center closes the loop: the lab points the installed application’s own engine at a swappable home directory, so an edit to the persona is read by the very next run. No rebuild, no release, no wait.

The 45-minute figure is the operator’s account of the build he was waiting on, not a measured benchmark. It is recorded here as motivation rather than as a metric.

G is the single assistant inside GBuild, a fork of the Hermes agent with a rewritten identity and a posture that is the actual product decision. Most assistants are permitted to end a turn with a dead end: I can’t do that, or here is what you should go and do. G is not.

The persona names the rule directly. Every “can’t” becomes a path, in order: unlock it yourself when that is reversible and in scope, raise the one card that asks for exactly the missing grant when it needs a human hand, or ask the fewest questions that let you act. Questions gather what is needed to move; they are never a way to hand the work back.

That last clause is why this matters beyond the developer running it. A person who cannot code is not blocked by the task, they are blocked by the instruction. “Open system settings and grant accessibility, then re-save it as a PDF” is a perfectly clear sentence and a wall. An agent that does the thing, or that raises one specific card and then does the thing, removes the wall rather than describing it.

GBuild shipped 33 expertise overlays. None of them had ever been validated. The project’s own record of the problem is the sharpest statement of it: they were not broken because nobody built them, they were broken because nobody could tell whether they worked.

The tempting question is which ones to migrate. The honest question comes before that: does the overlay change any outcome at all? If it does not, 33 files delete with no replacement channel needed, which is a far larger simplification than any migration.

Answering it runs into something that quietly defeats most agent evaluation. The engine is stochastic. Ask it the same thing twice and the two answers differ. So a rule of “the arms came out different, therefore the overlay did something” can never reach deletion, because it will fire for a completely useless overlay just as reliably as for a good one. Under that rule the screening always says keep, and the screening is worthless.

The two identical arms are the instrument. The distance between them is the engine’s own noise floor, measured on the same day, on the same machine, under the same conditions as the treatment. An overlay counts as having done something only when it separates from the control by more than the control separates from its own twin. Anything less is overhead: system-prompt tokens on every single turn, buying nothing that can be distinguished from the engine having a different morning.

Repetitions interleave across arms rather than running one arm to completion at a time, so slow drift in the engine or the network spreads evenly instead of landing entirely on whichever arm happened to run last.

The posture in the persona is enforceable rather than aspirational, and this is where the novice-user thesis stops being a value statement and becomes a table. Production carries two phrase lists. A reply matching either is rejected and re-run with a directive explaining what it did wrong.

The homework directive is the clearest single sentence in the system, and it is worth quoting as written:

“You have cards for exactly this. Raise the permission request for a macOS permission, the connect card for an account, a tool request for a missing capability, or an approval otherwise, then do the job yourself. If a surface is worth showing, it is brought to the operator, never pointed at.”

Brought, never pointed at. That is the difference between an assistant that is useful to someone who already knows the software and one that is useful to someone who does not.

Typing a prompt fresh every time is how a test suite becomes anecdote. The left rail holds saved prompts grouped by the surface they exercise, each runnable individually or as a group, at roughly 20 seconds a run.

The groups map to the surfaces G actually appears on: plain conversation, where voice, warmth, and proactivity are the whole test; maps knowledge through the mapping tools; macOS control, where the interesting moment is the confirm-before-acting pause on anything destructive; and native application work through the same tool surface the product uses. A group carries its own caveat where one applies. The maps group notes that production voice runs an inline path rather than this one, so routing has to be verified separately rather than assumed from a passing run here.

Every run lands in an append-only ledger with its prompt, its settings, and its grade if it has one. Each distinct persona hash becomes a version, and the compare view puts versions against scenarios so a persona edit can be read as a column rather than as a memory of how it used to answer.

A lab that slowly stops matching the product is worse than no lab, because it keeps producing confident results about something that no longer exists. Three mechanisms hold the two together.

The parity manifest is generated from the production Rust source, not hand-written: envelope fragments, tool-gating tables, session and timeout values, the response-guard phrase tables, and configuration defaults are all emitted by a build command and checked fresh by a pre-commit gate. Hand-editing it is explicitly forbidden, which removes the failure where the lab is corrected to match a belief rather than the code.

The persona hash is compared against the shipped file on every load, and any difference raises a visible drift warning rather than being left to be inferred from a surprising answer. The deployment script derives the shipped file set from the actual import graph, so a module that is imported but missing fails the deploy loudly instead of shipping a bundle with a hole in it.

It is an internal instrument, not a product. It binds to loopback only, it is never publicly reachable, and it has no users in any sense that would make a usage number meaningful. There is no deployment to point at.

The overlay verdict is also not in yet. The instrument exists, the arms run, and the question it was built to answer, whether 33 overlays earn their tokens, is still open. Real runs cost money and are gated behind an explicit environment flag, and the dry-run path uses a deterministic stub precisely so the machinery can be exercised and self-tested without spending anything or pretending a stub result is evidence.

137 commits over 41 days. Roughly 10,953 lines of hand-written JavaScript and HTML, of which 1,846 are its own self-tests, plus 38 contract-test files and 31 local endpoints.