DESIGN.md cost 7.21 million tokens and produced roughly 30% design-system adherence. A dedicated MCP server, running the same task, cost 3.75 million tokens and hit roughly 80%. Those are the headline numbers from Atlassian’s first-party benchmark of portable design context, and they are the first hard figures on a question the agent-governance conversation has dodged: what does it actually cost to hand an agent your rules as a portable file?
The honest framing first. This is a vendor self-test, and the vendor sells the MCP-based tooling that wins. Read the absolute percentages as directional, not gospel. But the shape of the result is independently useful, because it measures something we have only asserted before. Governance context is not free, and the cheapest-looking option to author can be the most expensive to run.
What DESIGN.md Promised and What It Billed
Google’s DESIGN.md format is a portability play. You capture your design system as a single readable file, drop it into the context window, and any agent on any tool can read it. No server to host, no integration to maintain, no per-tool wiring. For a discipline drowning in tool sprawl, that portability is genuinely attractive.
Atlassian tested four approaches against the same generation task. No context at all burned 4.20 million tokens and produced about 5% adherence to the design system, which is the baseline for slop. The Atlassian Design System MCP server burned 3.75 million tokens and reached about 80% adherence. DESIGN.md burned 7.21 million tokens and reached about 30%. So the portable file cost roughly 92% more tokens than the server and delivered well under half the compliance.
The variance number matters as much as the token count. DESIGN.md showed 2.7 times the run-to-run variance of the MCP approach. Same input, same rules, different output each time. For a governance artifact, inconsistency is the whole failure. A control that enforces 80% on Monday and 30% on Thursday has stopped governing; it has become a suggestion with a good week.
Why the Portable File Costs More and Enforces Less
The mechanism is straightforward once you look at what each approach actually delivers to the agent. DESIGN.md is a static snapshot of prose and tokens. It describes the system. The MCP server exposes the system as callable structure: component libraries the agent can query, lint rules it can run against its own output, live references it can resolve on demand.
A static file forces the whole payload into context every time, whether the task needs all of it or none of it. That is where the 92% token premium comes from. The agent reads everything to use anything. A server hands over only what the current call requires, and it hands over the parts that enforce rather than merely inform.
This is the part the portability pitch glosses over. Atlassian found DESIGN.md drops the component libraries and the lint rules. Those are not decoration. The lint rule is the enforceable boundary, the thing that says no when the agent drifts. Strip it out and you have shifted compliance from the system onto the individual agent’s good judgment, prompt by prompt. The file tells the agent what good looks like. The server makes good the only thing the agent can ship.
The Same Lesson, Now With a Price Tag
We have argued before that the design system is not the real constraint, that the encoded rationale is what actually governs an agent’s output. The Atlassian benchmark is the same argument arriving with a meter attached. A portable file is a description of intent. A server with lint rules and queryable components is intent made enforceable at generation time.
The token cost makes the tradeoff concrete in a way prose never did. Portability buys you reach: any agent, any tool, no integration. It bills you in tokens and in variance, and it quietly drops the enforcement layer on the way. The cheaper artifact to write is the more expensive artifact to trust. When you choose portable context over a real governance interface, you are not just paying more per run. You are paying for a control surface that holds two times out of three.
This connects to a pattern we keep finding in agent tooling. The convenient shortcut around the structured layer usually works in the demo and frays in production, because the structure was doing load-bearing work nobody priced. The constraint layer is exactly what makes the effort worth shipping, and it is the first thing skipped to save work.
Portability Still Has a Job
None of this kills DESIGN.md. A portable snapshot is a fine handoff format: onboarding a new tool, sharing intent across an org boundary, giving an external agent a starting frame it would otherwise lack. The error is treating the snapshot as the enforcement layer. Portability and governance are different jobs. A file can carry your design system across a boundary. It cannot make an agent obey it.
The 92% premium is the price of confusing the two. You pay server-grade tokens for file-grade compliance, and you absorb triple the variance on top. If portability is what you need, accept the cost knowingly and keep a real enforcement path behind it. If governance is what you need, the file is not it.
Do This Now
Find one place where an agent reads a portable context file (a DESIGN.md, a CONTRIBUTING-style brief, a pasted style guide) and treats it as governance. Run the same generation task twice and compare the outputs against your actual rules. If adherence drifts between runs, you have a description where you needed a control. Move the enforceable parts (the lint rules, the queryable component definitions, the hard boundaries) behind an interface the agent must call, and keep the portable file for what it is good at: carrying intent across a boundary, not enforcing it once inside.
This analysis synthesizes Atlassian’s DESIGN.md is here: what we learned testing portable design context (Atlassian, June 2026). The benchmark is a vendor self-test favorable to its own MCP tooling; treat the figures as vendor-reported and directionally useful.
Victorino Group helps teams turn portable context into enforceable governance that an agent actually obeys at generation time. Let’s talk.
All articles on The Thinking Wire are written with the assistance of Anthropic's Opus LLM. Each piece goes through multi-agent research to verify facts and surface contradictions, followed by human review and approval before publication. If you find any inaccurate information or wish to contact our editorial team, please reach out at editorial@victorinollc.com . About The Thinking Wire →
If this resonates, let's talk
We help companies implement AI without losing control.
Schedule a Conversation