DEV Community: Odd Essentials

Build Like an Onion, Govern Like a God

Odd Essentials — Fri, 23 Oct 2026 20:17:32 +0000

How to scale agentic builders to infinite

One core, every surface. agentguild.oddessentials.ai

Two days, seven platforms

Agent Guild went from a web page to Steam, VS Code, iPhone, iPad, Vision Pro, Apple Watch and Apple TV in two days. Not two days per platform. Two days for all of them, once the core existed.

That sentence gets one of two reactions. Engineers who have shipped a cross-platform product assume it is marketing. Engineers who have been building with agents for the last year nod, because they have watched it happen. Both are missing the point. The speed was never the agents. The speed was the shape of the thing the agents were building on.

Next up are Google Play, Android, Fire TV and Samsung. I expect them to take a day. Not because the agents got better since last week, but because the onion already has its core.

Build like an onion

An onion has a core, and every layer is the same shape as the core, one size larger. Nothing in the outer layer knows anything the inner layer does not. Peel any layer off and what is underneath still works.

That is how Agent Guild was built. The core is a local manager with one job: own the sessions, own the state, expose both over a small API. It does not know what a screen is. The web page was the first layer. It talks to the core and nothing else. The Steam build, the VS Code extension and every Apple target are further layers, and each one talks to the same core through the same API. None of them carries its own copy of the truth. When a new platform shows up, the question is never "how do we make this work" but "what does this layer need to render the core." That is a day's question.

The alternative is the Frankenstein build, and almost everyone does it because it feels productive. You have a working app. Somebody wants it on a phone, so you bolt on a phone. Somebody wants it in their editor, so you graft an extension onto the side. Each addition carries a little of its own state, its own assumptions about where the data lives, its own idea of what "logged in" means. The sixth platform is harder than the fifth. The tenth never ships. Dr. Frankenstein did not fail because the parts were bad. He failed because nothing he stitched together shared a spine.

Agents make this worse, not better, if you let them. An agent will happily bolt on a seventh limb, and it will do it fast. The faster you build, the faster patchwork becomes unmaintainable. The onion is the only shape that gets faster as it grows, because every new layer is cheaper than the last one. That is what "infinite" means in the title: not that you will ship infinite platforms, but that the marginal cost of the next one keeps falling instead of rising.

Govern like a god

Every agentic framework on the market right now sells governance as a folder of markdown files. Put the rules in CLAUDE.md, put the conventions in AGENTS.md, add a few .cursorrules, and the agents will behave. I want to be fair to this: it gets you further than you would guess. A well-written instructions file is the cheapest productivity gain in the whole stack, and I keep mine current.

But it is not governance. It is a request. A markdown file asks the agent to behave. Governance is what happens when the agent does not.

Governance means taking personal responsibility for five things, and "personal" is the operative word. You do not delegate these to the agent that is being governed.

The automated test suite. Not the tests the agent writes to make its own PR green. The tests that define what the product is, that run on every commit, that an agent cannot edit without a human noticing. If the agents own the tests, there are no tests.
The CI/CD pipeline. Every layer of the onion ships through the same pipeline. The pipeline is the one place where "works on the agent's machine" dies. It builds every target, runs every suite, and refuses to publish anything that fails. An agent can propose a change to the pipeline. It cannot merge one.
Resource management. Agents do not get tired, and they do not get a bill. You do. Token budgets per task, compute caps per session, rate limits per provider, a kill switch that is one keystroke away. The day you let an agent loop unattended with an uncapped budget is the day you learn what "infinite" costs.
Failsafes and stop points. Some actions require a human before they continue. Publishing to a store. Rotating a credential. Deleting anything. Touching the pipeline itself. These are not suggestions in a markdown file; they are gates the agent physically cannot pass. A stop point that an agent can argue its way through is a speed bump, not a gate.
VMs, sandboxes, containers. Contain your environment.

"Like a god" is not about control for its own sake. A god does not micromanage; a god sets the physics. The agents are free to do anything the physics allow, and the physics do not allow them to break the build, exceed the budget, or ship without a human at the gate. Inside that, let them run.

The boring technical part, which is the whole point

The tooling that makes this work is deliberately dull. Lightweight CLI tools, not IDE plugins and not platforms. Claude Code, Codex, Gemini CLI: whichever the task calls for, and often more than one on the same task, because CLIs compose and GUIs do not. A CLI can be piped, scripted, scheduled, diffed and killed. That is the entire reason governance is possible. You cannot put a stop point in front of a button.

Agent Guild's web page: every CLI tool side by side, each with its own accounts, usage and launch flags. Sample data.

Every one of those agents runs the same deterministic processes: the same build scripts, the same test runners, the same lint, the same release checklist. The agent is the thing that varies. The process is the thing that does not. Swap the provider tomorrow and the pipeline does not notice, because the pipeline never trusted the provider in the first place.

And where it is feasible, the same processes run against local models. Not for the hard reasoning, but for the long tail: classification, summarization, first-pass review, the hundred small calls that would otherwise cost money and leave the building. A local model is a resource you own, with a budget you can see and a network boundary you control. That is governance by default, which is the best kind.

The commands you keep retyping, turned into buttons: Agent Guild's productivity features.

What infinite means

Infinite does not mean unlimited. It means the next platform costs less than the last one, and that curve never turns back up. The onion gives you the shape. Governance gives you the confidence to let agents run at the speed the shape allows.

We will know by tonight whether Google Play, Android, Fire TV and Samsung took a day. I am writing this before we start, so there is no hiding if they did not. But the core has not changed, the pipeline has not changed, and the gates are where they were. If it takes two days, the onion is fine and I was wrong about the day. If it takes a week, something grew a limb, and I will go find it.

Agent Guild runs on the web, Steam, VS Code, iPhone, iPad, Vision Pro, Apple Watch and Apple TV, all from one core.

Get it at agentguild.oddessentials.ai

Visualizing Coding Agents Across Providers

Odd Essentials — Thu, 22 Oct 2026 03:30:38 +0000

Four agents were working for me on a Tuesday night. One was rewriting a database layer, one was chasing a flaky test, one was drafting docs, and one was doing something to the build that I had stopped following an hour earlier.

At 11:40 the fourth one went quiet.

Was it finished? Stuck? Sitting on a permission prompt, politely waiting for me to type "yes" while I was in another window? The screen had simply stopped moving.

That silence is why I built Agent Guild, a local page that runs every coding agent CLI side by side and draws what each one is doing. This post is about the drawing: how you visualize agents from five vendors who each describe their work differently, and where the picture has to admit it can't see.

A terminal is a river of characters

A terminal does not label anything. Nothing on the screen says "this is a shell command" or "this is the agent asking for help". If the screen is all you have, you are guessing from the shape of the text, and the guess breaks every time a vendor changes a spinner.

So the screen can't be the source of truth. Every modern coding agent has hooks: a way to run a small program when something happens, such as a turn starting, a command running, a helper agent being spawned, or a permission being requested. Agent Guild installs a small reporter into each tool's hooks at launch. The reporter turns each event into a short message to a local manager: "session 12 ran a shell command", "session 12 is waiting on permission", "session 12's helper finished".

The screen becomes the fallback. The only thing taken from it is whether output is still flowing: a card says Working while it is, and drops back when it stops. That is an inference, and the page treats it as one.

Layer one: the board

The first picture is a board of cards. One card per tool at the top, with its account, usage left and model grades. One card per session below, with the model in use, the working folder, and the session's helper agents as lettered circles.

Look at the Antigravity session in the bottom left. Its agents row says reporting off, with a Why? beside it. That is the most important pixel on the page. A blank row would look like "no helpers running". Saying "I can't see this" is the difference between a dashboard you can trust and one that quietly lies.

Five crews, five dialects

The board is only as good as what each tool will tell it, and the tools disagree a lot. Here is what each one reports today:

What the board can show	Claude Code	Codex CLI	Grok Build	Docker Agent	Antigravity CLI
Model in use	Yes	Yes	Yes	Yes, from 1.100.0	Yes
Helper agents	Yes	Yes	Yes	Yes	No
Shell commands	Yes	Yes	Yes	Only the ones it asks about	No
Waiting on your permission	Yes	Yes, but not refusals	No	No	No
Turn ended by an error or a cancel	Yes	Cancel only	Yes	No	No
Usage left	Yes	Yes	No	No	No

A few of those cells took real digging:

Codex CLI reports a permission request but never says the command was refused, so a command it asked about is closed at the end of its turn instead of sitting on the board forever.
Grok Build lists a good set of events, but the exact message shapes weren't in its public docs; I read them out of the program itself. It never reports a permission request, so a command waiting for approval looks the same as one still running.
Docker Agent fires no pre-tool hook for commands it runs without asking, so in autonomous mode its shell commands are invisible to hooks.
Antigravity CLI reports the model, its conversation and each turn's answer, and nothing about helpers or commands.

None of this fails loudly. The card for a Grok session simply shows less than the card for a Claude session, and a reasonable person assumes the app is broken rather than the tool being quiet. Half the work went into making the gaps visible instead of empty.

Layer two: the Yard

Cards are good for reading. They are bad for glancing. With six sessions open, I wanted to know who needed me without reading any text at all.

So the same facts are also drawn as a place. In the Yard, each tool is a hall, each session is a character working outside its hall, and each helper agent is a smaller figure that works, waits, idles or finishes. The roster and an inspector sit beside it, and double-clicking a character opens its terminal.

Each world draws the same sessions differently. In Goblinville Works it's a smithy crew on a boardwalk; on Orbital Station it's a crew outside domed pods.

The Yard reads the same reports as the board. It doesn't know anything more. A Grok character has nothing to show for a permission wait, for the same reason the Grok card doesn't. What changes is how fast your eye finds the one that stopped moving.

The Yard also fits places a board doesn't: there's a VS Code extension that shows it in a small view beside your code, and the whole page works from a phone over Tailscale. The sessions run in a background manager rather than the browser, so closing the tab, or walking away with your phone, doesn't stop anything.

Quiet is not done

Suppose every tool reported perfectly. You still wouldn't know if the work was finished.

Every hook that sounds like "finished" means something smaller. A stop event fires at the end of every turn, not the end of the job. A session-end event is a cleanup signal that doesn't fire if the process crashes. Even the final result record of a headless run only tells you the agent stopped talking.

The people running agents unattended have all landed on the same answer, and it isn't a hook. It's evidence: the tests pass, the pull request exists, the CI run is green, a second reviewer found nothing. The controller decides what done means, never the agent.

That reframed what a visualization is for. It can't tell you the work is finished. It can tell you, as honestly as each vendor allows, what every crew is doing and which one just went quiet, so you open the right door at the right moment. The checking is still yours.

Try it

With Node.js 22 or newer, on Windows, macOS or Linux:

npm install -g @oddessentials/agent-guild
agent-guild

Or try the demo in your browser, simulated with nothing installed.

I'd love to hear how you keep track of agents from several vendors, and which gaps in that table bite you most. If you know a hook I've missed, tell me in the comments.