applied-ai2026-08-139 minNikolay Angelov

The Model Is No Longer the News

Three things from the summer of 2026, and what connects them.

The model is no longer the news

If you only read headlines, this summer looks like business as usual: a few new models, another wave of frameworks, another revision of a specification.

This isn't just a list. The three things below happened independently, in three different parts of the ecosystem, and they point in the same direction:

The industry is shifting from optimizing the model to building out the system around it.

This article isn't a prediction but an attempt to interpret something that is already happening — it was simply scattered across so many separate news items that it was hard to notice as a trend. And it doesn't mean the models have stopped mattering: it means a growing share of the engineering advantage is shifting to the system around them.

1. MCP Went Stateless

What happened. On 28 July 2026 the new Model Context Protocol specification landed. The change at its core is a single one: the protocol moved from bidirectional and stateful to stateless request/response. Every request describes itself, which means an MCP server can now sit behind an ordinary round-robin balancer — no sticky sessions, no shared state store, no gateway digging through the request body.

Along with it:

  • Header-based routing. The method and the tool name travel in Mcp-Method and Mcp-Name, so a gateway can route and authorize without parsing JSON.
  • Cacheable listings. tools/list returns ttlMs and cacheScope.
  • An extension framework. Tasks, MCP Apps, and Enterprise Managed Authorization move out of the core and become official extensions — Tasks with poll-based tasks/get.
  • Multi Round-Trip Requests. The server can ask for input mid-call by returning resultType: "input_required"; the answer is attached on the follow-up call.
  • Hardened authorization — RFC 9207 issuer validation, credentials bound to the server that issued them.
  • A formal deprecation policy. Roots, Sampling, Logging, dynamic client registration, and the legacy HTTP+SSE transport are deprecated, with a guaranteed window of at least twelve months.

Why it matters. The first two are boring, and that's exactly why they're important: these are the changes you make when something has to move from demo to production. The chain is straight, and all of it leads to one place:

stateless → horizontal scaling → ordinary load balancing → caching → gateway-friendly routing → production readiness.

Balancers, caches, gateways, a guaranteed migration window — that's the vocabulary of infrastructure, not of a prototype.

From stateful to stateless MCP: horizontal scaling, load balancing, caching, and gateway routing

What changes architecturally. Two of the most visible differences between A2A and MCP — the durable task lifecycle and the ability to ask for additional input — are no longer so distinct. If you were choosing between the two protocols on the criterion of "which one can ask back," that criterion no longer works.

This doesn't make the two equivalent. A2A retains far richer semantics around agent identity and discovery, task context, artifacts, delegation, and the asynchronous lifecycle. But the technical difference stopped being the dividing line.

In my view that's good news, because it puts the boundary back where it always belonged: tool versus judgment, not technical capability.

What it means in practice. If you have an MCP server, look at it through the new lens: does it hold state between requests, does it depend on an open stream? If so — you have twelve months and a clear framework. If not — your system is already scalable enough without doing anything.

2. The Harness Got Productized

What happened. On 17 June, Vercel released Eve — an open framework for agents, TypeScript and Markdown, "filesystem-first": an agent is a directory of files describing instructions, skills, tools, channels, and schedules.

The capability list is worth reading slowly: durable execution, human-in-the-loop approvals, subagents, sandboxed execution, OpenTelemetry tracing, evals. The project is in preview.

Eve isn't alone. Mastra, LangGraph, CrewAI, the Agents SDK, and several others position themselves in the same category with surprisingly overlapping lists.

Why it matters. Because that list isn't arbitrary. Different teams, different languages, different architectural philosophies — and yet they all lead to the same set of runtime primitives:

durable execution · state and checkpointing · approvals · subagents · sandboxing · tracing and observability · evals

When five separate teams arrive at the same structure, the structure is probably real.

The terminology is shifting too. Increasingly, the practical formula looks like this:

Agent = Model + Harness

Not an official definition, but a working way to think — with the caveat that the differences between leading models are less often the sole determining factor, while the harness around the model does a growing share of the work.

Agent = Model + Harness: orchestration, state, tools, approvals, subagents, sandbox, tracing, and evals

What it means in practice. If you're picking a framework right now, there are three criteria, and none of them is "how modern is it":

  • Portability. Eve is strongly Vercel-oriented as a production runtime and deployment model. There's an abstraction around sandboxed execution and there are local options, so "hard lock-in" is too strong a phrase — but if your target is another cloud or your own machine, that's a real cost to weigh up front.
  • Maturity. Eve is in preview. Every framework in this category is young; the differences in battle-hardening are real, but the public data doesn't support a ranking.
  • Language. Eve and Mastra are TypeScript-only. LangGraph has a strong focus on state and checkpointing and remains Python-first.

3. Models Are Stratifying, and Routing Is Becoming Practice

What happened. The summer was dense: Claude Fable 5 on 9 June, GPT-5.6 in July, Grok 4.5 on 16 July, Gemini 3.6 Flash on 21 July, Claude Opus 5 on 24 July. Prices fell in several directions at once.

Three things in that wave are more interesting than the models themselves.

The first is the naming. OpenAI introduced a scheme in which the number describes the generation, while Sol, Terra, and Luna describe a durable capability class: Sol for the deepest reasoning, Terra for balance, Luna for speed and volume. The three tiers advance on their own schedules, so upgrading one doesn't rename the whole family.

That's an admission baked into the naming scheme itself: no single model is expected to be optimal for every task. Capability, latency, and cost are now separate architectural dimensions, not points along a single axis.

The second is that availability became a variable. GPT-5.6 Sol first shipped as a limited preview to a small number of trusted organizations at the request of the US government, while OpenAI coordinated with the administration on the framework around frontier models and cybersecurity.

The more dramatic case is Anthropic's: on 12 June the US government imposed export controls on Claude Fable 5 and Mythos 5. Because the rule took effect immediately and there was no way to verify every user's nationality in real time, Anthropic pulled both models for everyone. The restrictions lifted on 30 June, and Fable 5 returned globally on 1 July — nineteen days of downtime.

The third follows from the first two. The question is gradually shifting from "which is the best model?" to "which model is right for this particular step?" — and the dimensions you choose along are now seven:

capability · reasoning depth · latency · cost · risk · regulatory availability · task and context type

Routing between Sol, Terra, and Luna by capability, reasoning depth, latency, cost, risk, and availability

Regulatory availability is the new one on that list, and it's exactly the lesson of June: the model that was the best choice yesterday may be unavailable today for reasons that have nothing to do with its quality.

What it means in practice. More and more agentic systems and platforms allow a different model for different roles and steps — a more capable one for planning, reasoning, and decisions; a cheaper and faster one for mechanical execution, classification, extraction, and parallel subtasks.

For workloads with clearly distinguishable task types, routing can be one of the most direct cost optimizations available, without necessarily sacrificing quality where quality matters.

"Which is the best model" was the right question while the differences were enormous. Now it's like asking which is the best programming language.

What Connects Them

Three different parts of the ecosystem, three different kinds of change: a protocol, tooling, a model market. The same vector.

What changed From To
MCP bidirectional, stateful stateless, cacheable, behind a balancer
Frameworks "how do I call a model" durable execution, approvals, tracing, evals
Models "which is the most capable" which one for which step, at what cost and availability

There's also a backdrop that isn't news. Gartner forecasts that over 40% of agentic AI projects will be scrapped by the end of 2027 — due to escalating costs, unclear business value, and inadequate risk controls.

It's tempting to read that as "the problem isn't the model." It isn't that simple — Gartner also points to limitations in the maturity of the models themselves. The more accurate reading is that the problem is far from being only intelligence. Cost, integration, risk, operational maturity, and the absence of clear business value turn out to matter at least as much.

Regulation is moving in the same direction. From 2 August 2026 another significant part of the EU AI Act applies, including the transparency obligations under Article 50. Compliance stops being a policy exercise and becomes an operational constraint on the system — that is, one more requirement on the harness, not on the model.

The three news items above aren't a coincidence. They're a response.

The frontier model still matters and will continue to. But a growing share of the real competitive advantage comes from what surrounds it: the protocols, the harness, orchestration, state, evals, observability, routing, and operational discipline.

The model is no longer the whole system. And increasingly, it isn't the hardest part of it.

Sources and notes

The comparative judgments about the frameworks and the conclusion about the boundary between MCP and A2A are the author's, not conclusions drawn from a specification or a benchmark.