Writing
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.
Notes
Model releases get most of the attention because capability is easy to see. A benchmark moves, a context window grows, or a new modality appears.
The integration problem is less visible. A model can be excellent at reasoning and still be almost useless inside a real company if it cannot reach the files, repositories, databases and tools where the actual work lives.
Anthropic's Model Context Protocol, released four days ago, is aimed at that layer. My interest in MCP is not that it gives Claude another way to call a function. The larger idea is that model applications and external systems may finally get a shared connection contract.
If that works, the protocol layer could matter longer than any individual model release.
The integration problem scales badly
Today, every AI product tends to build its own connectors.
A coding assistant needs GitHub access. A research tool needs document stores. An internal assistant needs Slack, Google Drive, Postgres and whatever private systems the company has accumulated. Each application implements authentication, data retrieval, schemas and tool definitions in its own way.
Add another AI client and much of that work gets repeated.
Anthropic describes this directly in the MCP announcement: every new data source currently tends to require a custom implementation. MCP tries to replace that pattern with a common client-server protocol. Data providers expose MCP servers; AI applications connect through MCP clients.
The value of a protocol is that the same integration can become usable by more than one application without being rewritten around each model vendor.
MCP is more than function calling
Function calling solved a narrower problem: how does a model request a structured operation from the application that is already hosting it?
MCP moves the boundary outward.
The November specification defines a host, clients inside that host, and independent servers that expose context or capabilities. Communication uses JSON-RPC 2.0, with connection lifecycle and capability negotiation built into the protocol.
Servers can expose three main primitives.
Resources provide context such as files or application data. Prompts expose reusable interaction templates. Tools expose executable operations with names, descriptions and JSON Schema inputs. A client can discover those capabilities instead of requiring every integration to be hard-coded into the application.
There is another interesting direction in the first specification: sampling. An MCP server can ask the client to perform a model generation while the client keeps control over model access and permissions. This means the server does not necessarily need to own an API key or depend directly on one model provider.
That separates three things often bundled together in AI applications: the model, the host application, and the system providing data or actions.
Context is becoming infrastructure
Earlier this year, the conversation around model capability was dominated by larger context windows. Gemini 1.5 made one million tokens feel plausible as a working set. That solves part of the problem, but a context window does not decide where project information comes from.
Something still has to find the repository, query the database, read the current project state and decide what can be exposed to the model.
MCP treats that connection as infrastructure rather than prompt construction.
A standard resource interface means an application can request context from the system that owns it rather than copying everything into a proprietary connector format. The initial protocol supports capability negotiation and resource-change notifications, which points toward state that can be discovered and updated rather than pasted once into a prompt.
For me, that is a better abstraction than treating "context" as a larger text box.
What this could mean for production pipelines
The same pattern maps well to creative and technical production.
Imagine a 3D pipeline with Blender scenes, an asset database, render jobs, project documentation and an engine build system. I would not want one giant AI integration that knows the internal API of every component.
I would rather expose narrow capabilities at the boundaries.
An asset server could provide asset metadata and validation tools. A render server could expose job status and submission operations. A project server could provide naming rules, export presets and documentation. A Blender-side integration could expose controlled operations where direct scene access is needed.
The model application would then consume those capabilities through one protocol instead of owning every integration itself.
Someone still has to define what validate_asset means, which files the model may access, or whether an export operation is destructive. MCP standardises the connection; it does not understand the production pipeline for us.
A useful connector can become part of the infrastructure rather than part of one chatbot.
The Language Server Protocol analogy is useful
The MCP specification explicitly cites the Language Server Protocol as inspiration.
That comparison makes sense.
Before LSP, editor vendors and language-tool authors often had to build custom integrations with each other. A shared protocol separated the editor from the language server. One language implementation could then work across several compatible editors.
MCP is trying to create a similar boundary between AI applications and context providers.
MCP is only days old, and standards become valuable through adoption, not specification quality alone. There is no guarantee that model vendors and software companies will converge on it. The architectural target, though, is clear: reduce the number of pairwise integrations between models and software.
The missing pieces are not small
I would not design a large production platform around the assumption that MCP is already a settled standard.
The November specification says authentication and authorisation are not part of the core protocol. Clients and servers can negotiate their own strategies. The specification places consent, access control and tool safety on implementers rather than pretending the protocol can solve them automatically.
A server that can read a repository or execute a database operation creates a real security boundary. External content can contain hostile instructions. Permissions need to be narrower than "the model can access this application." Audit logs, user confirmation and deterministic validation still matter.
Transport is early as well. The first specification defines local stdio connections and HTTP with Server-Sent Events, while warning implementers about authentication and network exposure for remote servers.
So I see MCP as a promising interface definition, not finished infrastructure.
My prediction: model choice becomes more replaceable
If MCP or something with the same architecture gains adoption, I think one consequence will be more important than easier integrations: model choice becomes less tightly coupled to the rest of the system.
Today an AI application often accumulates model-specific tool definitions, connectors and context-loading logic. Switching the reasoning model can mean rebuilding parts of the surrounding stack.
A common context protocol could move those integrations outside that dependency.
The asset system exposes its capabilities once. The database exposes its resources once. Different compatible AI hosts can consume them. The model inside the host can change without forcing every data source to change with it.
That is why I think MCP might matter more than another incremental model release.
Models will keep improving, and I expect we will replace them frequently. Infrastructure changes more slowly; a good protocol can sit underneath several generations of models.
Four days after release, it is far too early to call MCP a standard in practice. Anthropic has launched the specification, SDKs, Claude Desktop support and example servers, while Block and Apollo are listed as early adopters and several developer-tool companies are working with it. That is enough to test the architecture, not enough to prove the ecosystem.
Still, the direction makes sense to me.
The model race improves the intelligence inside the system. MCP is trying to standardise how that intelligence reaches the systems where the work actually exists.
If AI becomes an execution layer across software, that connection layer may turn out to be the more durable technology.
Sources
- Anthropic, Introducing the Model Context Protocol, 25 November 2024.
- Model Context Protocol, Specification, revision 2024-11-05.
- Model Context Protocol, Architecture, revision 2024-11-05.
- Model Context Protocol, Tools, revision 2024-11-05.
- Model Context Protocol, Sampling, revision 2024-11-05.
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.
Open Standards Outlive Model Generations
A year after the MCP bet, the argument can be checked against what happened rather than what was hoped.
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.
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.