Unity shipped an official Unity agent plugin — 31 skills for Claude Code and Codex — and a free Unity CLI, three weeks after I published a decision log that deliberately ended in triggers instead of a calendar reminder: when X breaks, do Y. Every trigger fired, one conclusion broke outright, and the option I closed that post by saying nobody was selling turned up as a first-party product. This is what the frame got right, what it got wrong, and why “adopt the brain, defer the bridge” turns out to be the reusable part.

Beat: a decision log is worth more than a recommendation precisely because it can be graded later. This post is the grading.

1. What Unity shipped, in the frame’s own terms

Recap brain/bridge/generator in two sentences, link back to the original post, then sort the news into the three buckets — the sorting is the argument:

Point: the frame’s value was never the taxonomy, it was that the three layers have independent adoption decisions. One launch, three different answers. A single verdict on “the Unity plugin” would have been wrong whichever way it went.

What this dates in the last post

Fold the corrections in here rather than back-editing the original, and say why in one line: that post is a dated decision log, and a log that edits its own history is worth less than one that gets graded in public.

Two things in it are now out of date, and both are worth stating in the open:

The entitlement claim was wrong within three weeks. I wrote that on a Personal seat the first-party bridge is not a free fallback. The Unity CLI and com.unity.pipeline are free, need no Unity AI entitlement, and run on Unity 6.0 LTS and newer. Worth noting the direction of my error: I understated a free option, so the cost of having read me is skipping something free rather than paying for something you didn’t need. I’d have corrected it in place if it ran the other way.

“Three different things are called Unity MCP” is now four. The CLI hosts a second first-party MCP — by most accounts free — alongside the entitlement-gated one in Unity AI Assistant. Sources still disagree on where that line falls. I wrote the section to complain the name was ambiguous; the ambiguity has since gotten measurably worse, which I’m taking as vindication rather than as a reason to stop naming things carefully.

Beat: this is the cheap half of being wrong in public. A dated log absorbs a drifted price without collapsing. A confident recommendation doesn’t.

2. The Unity agent plugin ships zero MCP servers, because Unity went CLI-first

The hard, checkable finding, and the post’s spine. Unity’s launch post describes the plugin as bundling “skills, the Unity CLI, and Unity’s MCP server for live Editor control.” Installed, claude plugin details unity reports:

Skills (31)  ...
MCP servers (0)

Resist the urge to call this marketing dishonesty — the more interesting reading is architectural. unity mcp lives inside the unity binary. It is a subcommand, not a separate product: start it and it exposes a connected Editor’s commands as MCP tools over stdio, and unity mcp configure writes itself into sixteen AI clients. So the MCP server Unity mentions does exist. It just isn’t a thing the plugin installs, because the plugin installs no software at all.

What you actually get is documentation. The unity-cli skill tells the agent how to drive the Editor; the CLI, the com.unity.pipeline package and unity mcp configure are three steps you take yourself, deliberately, afterwards.

That gap — between “installs live Editor control” and “documents how you’d set it up” — is the entire reason adopt-the-brain-defer-the-bridge is available as a strategy. The knowledge layer and the control layer shipped in the same box and are not welded together. Had the plugin configured a bridge on install, adopting 31 skills would have meant swapping bridges underneath a working project, and I would have declined the whole thing.

Beat: the thing worth checking was never the launch post, it was the inventory. And the thing worth noticing is that Unity built CLI-first and made MCP a mode of it — which tells you which one they expect to last.

3. CLI or MCP? The token cost decides it, not the capability

The question I kept expecting to be hard, and isn’t — because for Unity they are the same capability wearing two coats. Same binary, same commands, same Pipeline package underneath. Nothing is reachable through unity mcp that isn’t reachable through unity command. So this was never a power comparison; it is an ergonomics and context-economics one, and almost nobody frames it that way.

What the CLI route costs and gives. The unity-cli skill sits at roughly 240 tokens always-on and only unpacks its ~13k when it actually fires. It runs in CI, in cron, in a plain shell, under any agent, or under my own hands. unity command invocations go into scripts and get version-controlled; MCP calls don’t. And discovery is dynamic — the CLI lists whatever the connected Editor currently exposes, so a new command shows up without re-registering anything.

What MCP adds, honestly. Typed tools the model sees without reading a skill first, which means fewer malformed invocations. Richer returns than stdout text — screenshots being the fair example, since an image coming back from a tool is natural over MCP and clumsy over a pipe. Per-tool permissioning in the harness.

What decides it. An MCP server’s tool schemas sit in the context window permanently, once per tool, whether or not you use them that session. A CLI’s cost is one skill description until the moment you need it. When your bridge exposes a couple of dozen tools this is a rounding error. When it exposes a hundred and eighty, it is the single largest fixed cost in your setup, and you are paying it on every trivial question you ask about the project.

Beat, and it generalises past Unity: we are used to comparing tools on what they can do, and these do the same things. The real question is what they cost you before you’ve done anything at all. Context is a budget now. Tool surfaces are rent.

4. The honest price of a free brain: what the Unity agent plugin costs in context

Balance section — resist the free-is-free reflex.

• ~5,943 tokens always-on, every session, every repo.
• Of 31 skills, roughly 8 apply to my project. No IAP or LevelPlay (the web layer owns monetization), no tilemaps or sprite atlases (it’s 3D), no multiplayer (Photon is gone), no Unity-side localization — by design, since my Unity build renders no words at all.
• Enable/disable is plugin-level only. You cannot trim per-skill, so the 6k is take-it-or-leave-it.

Beat: “free” tooling bills you in context window. That is a real currency now, and nobody prices it on the box.

5. The trap that came with the brain

The unity-cli skill instructs: “when an Editor is available, drive it instead of hand-editing scene or asset files” — and documents unity pipeline install, which would add a package to my manifest.

So adopting the brain quietly imported an advocate for the bridge I had just decided to defer. Not malice, not even a flaw — the skill is correct in general and wrong for my specific standing decision. But a future session acting on that instruction would silently reverse a deliberate choice.

Beat, and the transferable one: skills carry opinions, and an opinion you did not choose is a decision made on your behalf. The mitigation is boring — write the standing decision down where the agent reads it, not just in your own head. Generalizes to any team adopting any vendor’s skill pack.

6. The option nobody sells you got sold

The punchline. I closed the last post recommending a batch-mode CLI entry point specifically because no vendor was attached to it — arguing that the durable choice was the one that survived every acquisition scenario. Two weeks later Unity shipped precisely that: free, first-party, live-Editor control, [CliCommand] custom tools, no AI entitlement.

Two honest readings, give both:

• Flattering: if your reasoning lands on a capability the platform vendor ships weeks later, the reasoning was tracking something real.
• Deflating: I recommended it because it was unowned, and it is now owned. The property I valued is the one that went away. A first-party CLI can be deprecated, entitlement-gated later, or folded into a paid tier — the vendor-free road now has a vendor on it.

I still think adopting it is right, and I notice the argument that got me there no longer applies. Say so plainly rather than claiming the prediction.

Also: it is not polished. Bearer tokens regenerate on domain reload and strand clients on 401s. The Editor still wants foreground focus before refreshing assets — the single quirk that has cost me the most time. ~0.80s per call. First-party means someone is on the hook, not that the edges are gone.

7. The conclusion that broke: modality, not capability

The honest failure. I wrote that generated meshes actively fight assets with radial mechanical symmetry, sharp edges, separable parts, and a pivot that must sit exactly on an axis — using my own spinning tops as the example.

That was an argument against diffusion text-to-mesh, and I wrote it as though it were an argument against generated 3D. GPT-6 Astra (3 September 2026) is a different modality: an agent operating Blender, writing real Python, rendering, revising. It can name object hierarchies, set an origin exactly on an axis, assign per-part materials, export FBX. Every specific objection I raised is an objection to the technique I happened to have in mind.

State the uncertainty properly:

• I have not tested it on my own tops. Capability correction, not a result.
• Published weaknesses are organic shapes and topology-heavy work; strengths are hard-surface, naming, materials, export. My case sits in the strong half, which is suggestive, not evidence.
• Access is the real blocker for a solo dev: on ChatGPT Plus, Astra is metered inside Work and Codex at 5–45 local messages per 5 hours. A multi-part hard-surface model with revision loops eats that. I deferred on cost, and I should be clear that I deferred on cost and not on capability, because those are different admissions.
• BenchCAD: 95.9% voxel IoU, against 84.3% for the model I actually use daily. Report it; don’t bury it.

Beat: the correction worth publishing isn’t “I was wrong about a product,” it’s “my rule was missing a qualifier I didn’t know it needed.” Rules that name a technique age; rules that name a capability don’t.

8. What I actually did

Short and concrete, so the post lands as a log and not an essay:

• Installed the skills plugin, user scope, all six repos. Free, additive, reversible.
• Left the bridge alone. No package added to any manifest.
• Promoted the Unity CLI to pre-chosen fallback, displacing the MIT community bridge in my trigger list.
• Recruited Codex as a generator, not a replacement brain — image generation routed into my existing agent on subscription billing rather than API metering, because asset generation is out-of-band by nature and the filesystem was always the integration point.
• Declined Blender MCP on metered cost. Trigger: when a shipping asset actually needs it.
• Wrote the deferred-bridge decision down where the agent reads it.

9. The reusable heuristic

When a platform vendor ships an AI tooling bundle, unbundle it before deciding, and give each layer its own answer:

• Knowledge is nearly free to adopt — additive, reversible, priced in context rather than money.
• Control is expensive to switch — the cost is never the tool, it’s the accumulated knowledge of one tool’s quirks, and you pay it again on every swap.
• Generation should be bought from whoever generates — bundled generators are resellers, and the modality moves faster than any bundle tracks.

Adopt the brain. Defer the bridge. Buy the generator direct.

Close on the thing that made the exercise worth it: the grading only worked because the original post committed to triggers rather than a verdict. A post that had said “here is what I recommend” would have been silently wrong for three weeks. One that said “here is when I will change my mind” got to be checked. That is the argument for writing decision logs, and it has nothing to do with Unity.

References to collect before writing

1. Unity — official plugin for Claude Code
2. Unity — official plugin for Codex
3. Unity — Meet the Unity CLI
4. Unity Docs — plugin for third-party agents (Claude Code, Codex, Grok)
5. Unity Docs — Pipeline package
6. GitHub — Unity-Technologies/unity-agent-plugin
7. Vindler — the Unity CLI: what ships, what is broken
8. OpenAI — GPT-6 Astra
9. Astra-in-Blender write-ups + BenchCAD numbers
10. Astra access/limits by plan (Plus = Work/Codex only, metered)
11. My own: Brain, Bridge, Generator: Comparing Unity MCP Options After the Coplay–Aura Acquisition

Written September 2026. Same caveat as last time, and it earned its keep faster than I expected: prices, tiers and licence terms will drift, this is a decision log rather than a benchmark, and the Astra section is a corrected capability claim I have not personally tested.