Agent Guild 如何以洋葱式架構擴展智能體開發，並以治理機制設下界限

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 four 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.
"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