Writing
Open Standards Outlive Model Generations
A year after the MCP bet, the argument can be checked against what happened rather than what was hoped.
Notes
A year ago, I wrote that MCP might matter more than another model release.
At the time, that was mostly an architectural bet. Model Context Protocol was only days old. Anthropic had published a specification, a few SDKs and example servers. The useful idea was not that MCP had already become a standard. It was that AI systems were starting to need a shared way to reach tools and data without rebuilding the same connector for every model.
One year later, that bet looks less speculative.
On December 9, Anthropic donated MCP to the newly formed Agentic AI Foundation under the Linux Foundation. The foundation is being launched with Anthropic, Block and OpenAI, with support from companies including Google, Microsoft, AWS, Cloudflare and Bloomberg. Anthropic says there are now more than 10,000 active public MCP servers and lists adoption across ChatGPT, Cursor, Gemini, Microsoft Copilot and Visual Studio Code.
That does not mean MCP is finished. It means the problem it addresses has become shared infrastructure.
Models move faster than integrations
The last twelve months made the difference in lifecycle obvious.
Model names change quickly. A model can be the default choice in January and feel old by summer. Reasoning modes change. Context limits change. Pricing changes. Entire model families can be replaced while the product around them remains.
Integrations move more slowly.
A production system still needs access to repositories, databases, internal services, file stores and business tools. Authentication has to work. Permissions have to be enforced. Data formats have to be understood. The connection needs logs, retries and predictable failure behaviour.
If every new model requires every external system to implement another proprietary integration, the architecture does not scale.
That is the part MCP tries to separate.
The model can change. The client can change. The system exposing the tool or data can keep speaking the same protocol.
Adoption matters more than specification quality
A protocol is useful only when unrelated parties choose to implement it.
That is why the important MCP story in 2025 is not a new field in the specification. It is the movement across vendor boundaries.
OpenAI added support for remote MCP servers to the Responses API in May. Microsoft announced broad first-party MCP support across GitHub, Copilot Studio, Dynamics 365, Azure AI Foundry, Semantic Kernel and Windows 11 during Build. GitHub moved MCP support in VS Code to general availability in July and extended it across other IDEs.
Then in September, GitHub announced that its GitHub App-based Copilot Extensions would be retired in favour of MCP servers. The reason it gave is the interesting part: Copilot Extensions were specific to Copilot, while an MCP server can be used by any compatible agent or chatbot.
That is what interoperability looks like in practice.
The value is not that every vendor uses identical internal architecture. They do not need to. The value is that the boundary between the AI system and the external capability can remain portable.
Open standards reduce the cost of changing your mind
For founders, this changes an important risk calculation.
Choosing a model is becoming a reversible decision. Choosing an integration architecture can be much harder to reverse.
If I build ten internal tools around one vendor's proprietary function format, switching the model may require rewriting the connection layer. If those tools expose a common protocol, the model becomes easier to replace.
That does not make model choice irrelevant. Different models still vary in tool selection, reasoning, latency and reliability. But the cost of testing another model drops when the rest of the system does not need to be rebuilt around it.
I think that is one reason standards become more valuable as models improve faster.
Fast model turnover creates pressure for slower layers to stabilise.
MCP is not the whole agent stack
I would not turn this into a claim that MCP solves agent architecture.
It does not manage long-running tasks by itself. It does not decide how memory should work. It does not verify that an agent completed a job correctly. It does not remove the need for authentication, permissions or application-specific validation.
A protocol can standardise how capabilities are described and invoked. It cannot decide whether those capabilities are safe to expose or whether the result is correct.
The same applies to the other projects joining the Agentic AI Foundation.
Block is contributing goose, an agent framework. OpenAI is contributing AGENTS.md, a convention for giving coding agents repository-specific instructions. These solve different problems from MCP. The Linux Foundation is putting all three under the same neutral foundation rather than collapsing them into one framework.
That is healthy.
An ecosystem becomes easier to build when separate layers have separate contracts instead of one framework trying to own everything.
This resembles other infrastructure transitions
There is a pattern here that software has seen before.
HTTP did not determine how every web application worked internally. SQL did not make every database identical. Language Server Protocol did not make every editor or programming language use the same implementation.
The point of the shared layer was narrower: agree on enough of the boundary that independent systems can work together.
AI infrastructure is reaching the stage where that matters.
Models are no longer isolated endpoints generating text. They are clients of tools, data sources and software environments. Agents are becoming hosts for multiple capabilities. Once that happens, proprietary one-off adapters become architectural friction.
The Linux Foundation is a sensible home for this kind of work because neutral governance can make it easier for competing vendors to invest in the same interface without one company owning the protocol. Anthropic describes vendor neutrality and community governance as explicit reasons for the donation.
The donation does not guarantee success. Standards can fragment. Extensions can become incompatible. Security requirements can force different implementations. A specification can survive while the ecosystem moves somewhere else.
But neutral ownership removes one obvious reason not to adopt it.
What this means for production pipelines
The value is easy to see in the kind of systems I work with.
A production pipeline may include an asset database, Blender tooling, render management, source control, build infrastructure, documentation and internal automation.
I do not want the Blender integration rewritten because we changed the reasoning model.
I do not want the asset database to understand whether the client is Claude, ChatGPT, Gemini or an internal agent.
I want the pipeline to expose a controlled capability such as validate_asset, get_render_status or find_project_rule, with authentication and project logic owned by the system that already knows those rules.
Then the AI layer can change independently.
This is similar to how I think about 3D file formats and pipeline contracts. A useful interchange layer should preserve the information different applications agree to share without forcing them to become the same application.
The more AI gets embedded across production tools, the more valuable that separation becomes.
My takeaway after one year
When I wrote about MCP in November 2024, the main argument was that model intelligence and context access were different layers.
I still think that distinction holds.
Models have improved quickly since then. The connection problem did not disappear. If anything, more capable agents made it more visible because they can use more systems and therefore need more integrations.
MCP's 2025 adoption suggests that the ecosystem is starting to treat those integrations as reusable infrastructure rather than features tied to one assistant. OpenAI, Microsoft and GitHub adopting the protocol independently is more meaningful to me than Anthropic adding another MCP feature itself.
The Agentic AI Foundation is an early sign that agent infrastructure may develop its own neutral standards layer.
I would still avoid assuming MCP itself is permanent. Another protocol could replace it. The specification will change. Some companies will keep proprietary interfaces where they have good reasons to.
The broader prediction is the part I have more confidence in now: models will change faster than the infrastructure connecting them to the rest of software.
That makes open boundaries valuable.
A model generation may define what an AI system can reason about this year.
A good protocol can define how several generations of models interact with the same world.
Sources
- Anthropic, Donating the Model Context Protocol and establishing the Agentic AI Foundation, 9 December 2025.
- Linux Foundation, Linux Foundation Announces the Formation of the Agentic AI Foundation (AAIF), 9 December 2025.
- OpenAI, New tools and features in the Responses API, 21 May 2025.
- Microsoft, Microsoft Build 2025: The age of AI agents and building the open agentic web, 19 May 2025.
- GitHub, Sunset notice: GitHub App-based Copilot Extensions, 24 September 2025.
More
Other write-ups
Approval Is Not Publication
Thirty seven items in the queue, one approved, nothing published. The last arrow in the diagram is the only one that pays.
Neural Rendering Is Crossing From Reconstruction Into Synthesis
Reconstruction filled in what sparse sampling missed. DLSS 5 generates appearance the renderer never computed.
The Renderer Is Becoming a Training Data Engine
The renderer used to sit at the end of the pipeline. Physical AI gives the same scene a second job: teaching a model.
Local AI Is Becoming a Compute Fabric
Local AI meant one model on one machine. Routing inference across the devices already on a network changes the unit.
Agent Infrastructure Is Becoming a Product Category
Every team used to build the loop, the store, the sandbox. That layer is being sold rather than written.
Choosing a local model with a stopwatch, not a benchmark
Three models, five hard tasks, code actually executed. The official build was 2.4 times faster and more accurate than a community repack of the same model.
We measured real time lighting against baked light, and baked won
A 3D product simulation that had to look like an offline render. The real time version ran at 60 frames per second and looked like clay. Here is the measurement and the architecture that replaced it.
What actually broke in an agency run by agents
Three failures from a delivery stack that runs on AI. None of them were the model's fault, and all three reported success while producing nothing.
A Task Without A Check Command Is Not Automated
If a task has no command that can fail, the pipeline advances on the appearance of work.
A Gate The Model Writes Is A Gate The Model Loosens
Three quality gates returned green while the work behind them was wrong, each for a different reason.
The Scoring Model Was Wrong And It Put The Worst Lead First
A weighted sum let one axis substitute for the other, so a company with money and no problem ranked in the top twenty.
Building Software Got Easy. Getting Value Out Of It Did Not
Aristo took weeks to build. Everything after the build is still in progress, and that gap is the whole story.
Capability Is Becoming an Operational Risk Surface
Safety questions used to be about the text. Once a model can act, the capability itself becomes something to operate.
The Scene Graph Is Becoming an API for AI
A scene graph exists for artists and software. Agents are becoming another consumer, and they need structure rather than pixels.
Animation Is Moving From Clips to Motion Priors
Authored keyframes and blended clips are giving way to asking which constraints define acceptable motion.
Materials Are Becoming Learned Programs
A material is texture maps, parameters and shader code. It is starting to become a small learned program that answers a rendering question.
Procedural Systems Are Expanding Beyond Geometry
Geometry Nodes started with a narrow name. Blender 5.2 puts physics, sound and object data through the same graph.
The Unit of AI Work Is Becoming the Task, Not the Turn
Chat taught us to think one turn at a time. Long-running agents make the task the thing that is scheduled, resumed and reviewed.
Game Engines Are Becoming Operating Systems for Worlds
Engines have been judged on what they render and simulate. The Unreal 6 roadmap points at operating a world rather than drawing one.
The Model Is Becoming a Replaceable Backend
Choosing a provider used to mean choosing an architecture. A stable interface makes replacement possible and evaluation makes it safe.
The Harness Is Part of the Capability
The same model behaves differently depending on context policy, tool design and execution feedback. That surrounding software is not neutral.
Physics Engines Are Becoming Trainable Components
A simulator predicts what happens next. A differentiable one can answer which parameter should change to stop the failure.
The Agent Needs an Environment, Not Just Tools
A search function and a database query were enough for short loops. Longer work needs a place to stand.
Coding Agents Are Becoming General-Purpose Computer Workers
Repositories were a friendly environment: text in, terminal actions, checkable results. That was a starting point, not a boundary.
Colour Management Is a Pipeline Contract
Blender 5.0 reads as better display options. Giving a file an explicit working colour space is an architectural change.
The Best Model May Be a Router, Not a Model
GPT-5 moves model selection inside the system. The interesting unit stops being which model and becomes which compute policy.
World Models Are Not Game Engines Yet
Genie 3 generates a navigable 720p world at 24 fps. Production work needs state you can inspect when something goes wrong.
Memory Is Becoming a System Capability
A follow-up to the long-context argument. Storing, selecting and expiring facts is turning into a named part of the product.
Coding Agents Change the Unit of Software Work
AI coding tools have been judged where code appears on screen. The boundary moves when the agent owns a task instead of a snippet.
Agents Need Protocols Between Each Other, Not Just Tools
Tool calling solves the inside of the loop. It says nothing about one agent reaching another built by a different team on another platform.
Agents Need a Runtime, Not a Prompt Loop
An agent is no longer well described as a prompt inside a while loop. The useful abstraction owns execution around the model.
Reasoning Is Not the Only Path to Better Models
Longer thinking improves maths and code. A model that solves a logic puzzle and misreads ordinary intent is not the better production model.
Rendering Is Becoming a Reconstruction Stack
Sparse samples, motion data and lower-resolution frames become a larger final result. Debugging becomes layered when reconstruction sits in the middle.
Agent Reliability Is an Evaluation Problem, Not a Prompting Problem
When an agent misses a step, the usual fix is a stricter prompt. The failure is more often in how completion is detected.
MCP Might Matter More Than Another Model Release
A model can reason well and still be useless inside a company if it cannot reach the files, repositories and tools where work lives.
Computer Use Is the Missing Layer Between Models and Software
Most integrations assume useful software exposes the right API. Much of real software never did.
Inference-Time Compute Is a New Scaling Axis
o1 improves when it is allowed to spend longer on a problem. A benchmark score without a compute budget is an incomplete number.
The Final Pixel Won't Come From the Renderer
Geometry, camera and scene structure stay reliable ground truth. More of final appearance is moving into learned systems.
Open Models Are Becoming Research Infrastructure
Llama 3.1 gets discussed as a benchmark result. The licence terms change which experiments are possible at all.
The Model Is Becoming a Runtime
Function calling, code execution and structured output turn inference into a loop. The model stops being a text generator and starts being a control layer.
Multimodality Changes the Architecture, Not Just the Interface
GPT-4o is easy to read as a faster interface. Training one model end to end across text, vision and audio is an architectural change.
Benchmark Scores Are Not Model Capability
Claude 3 posts 86.8% on MMLU and 50.4% on GPQA Diamond. The chart is useful and it is not the same thing as capability.
Long Context Is Not Memory
Gemini 1.5 makes a million tokens usable. A larger working set is not a system that decides what should survive the session.