Agents in production
Platform integration
Agentic AI updates for 2026: where models, protocols, and the tools layer actually stand, why projects keep stalling, and what's worth watching next.
The agentic AI conversation has shifted. A year ago, the question was whether agents could reliably complete multi-step tasks. Now they can — at least in demos. The question heading into 2026 is different and harder: why are so many agent projects still stalling at the same point, and what does real progress look like from here?
Our view: the model layer has run ahead of the tools layer, and the gap is now the bottleneck. Foundation models reason fine. Frameworks orchestrate fine. Agents fail because they can't reach the systems they need to act on. The interesting agentic AI updates of the last twelve months aren't about model capability — they're about the access layer underneath.
This piece walks through five things: where model capability actually got to, what shipped in the protocol and tools layer, why deployment rates haven't matched the hype, what enterprise buyers are now asking for, and what to watch through 2026.
Reasoning models, longer context windows, and tool-use accuracy all moved forward in 2024 and 2025. Claude, GPT models from OpenAI, and the Gemini family from Google now handle multi-step tool calls with enough reliability that the model itself is rarely the failure point in a stalled project. Industry benchmarks like SWE-bench (Princeton, with OpenAI's Verified variant) and TAU-bench (Sierra), along with internal agentic evals published by Anthropic and others, show steady, measurable progress on tasks that require planning and tool invocation.
What that means in practice: when an agent project fails today, it almost never fails because the model couldn't reason about the task. It fails because the model reasoned correctly, picked the right tool, and the tool either didn't exist, didn't work, or didn't have permission to do the thing.
This is a real shift from 2023. The implicit assumption then was that capability would unlock deployment. It didn't. Capability arrived; deployment didn't follow. Gartner's projection that over 40% of agentic AI projects will be cancelled by end of 2027 — driven by escalating costs, unclear business value, and inadequate risk controls — lands harder when you read it against the model progress of the same period. The models got better. The projects got cancelled anyway.
The single biggest agentic AI update at the protocol layer was Model Context Protocol (MCP). Anthropic announced it in late 2024. Through 2025 it became the de facto way agents discover and invoke tools across vendors. By the end of 2025, OpenAI's Responses API had MCP support, every major framework spoke it natively, and enterprise teams were standardising on it for internal tool catalogues.
This matters for one specific reason: before MCP, every agent framework had its own tool format. Building a tool meant building it three times for LangChain, the OpenAI Agents SDK, and whatever bespoke runtime the team had in-house. MCP gave the industry a shared contract. A tool defined once is now invokable from any compliant agent.
Protocol standardisation is necessary, not sufficient. MCP defines how an agent talks to a tool server. It says nothing about how the tools inside that server get built, maintained, or kept in sync with the products they wrap. The hard problem moved up the stack — from "how do agents call tools" to "who is going to build and maintain the thousands of tools an enterprise actually needs."
A wave of MCP gateway and MCP governance products launched through 2025 — companies like Portkey, Lunar.dev, and others. These sit between agents and MCP servers, adding observability, rate limits, and access controls. Useful, but they front tools that already exist. They don't help with the deeper problem: most enterprise products don't have tools to front yet.
If you read only the model release notes and the conference keynotes, 2025 looked like the year agents went mainstream. The deployment data tells a different story.
A widely cited MuleSoft 2025 Connectivity Benchmark figure suggests 95% of organisations face challenges integrating AI, and that data integration is the top blocker to AI adoption. The same report finds developers spend 39% of their time creating custom integrations. These aren't AI-specific numbers — they're the same integration tax enterprises have paid for a decade — but they fall directly on agent projects, which need more integration surface than any prior wave of software did.
The pattern we see talking to SaaS companies building agents is consistent enough to be predictable. The pilot works. A small set of high-value workflows get demoed to leadership. Then the team tries to expand from one workflow to ten, or from one product to a portfolio, and the integration cost goes non-linear. Each new workflow needs new tools. Each new tool needs to be built, tested, secured, and maintained. The team that shipped the pilot in six weeks is now staring at an eighteen-month roadmap to reach what leadership thought was already done.
The shift in what enterprise buyers ask about during 2025 was striking. Through 2024, the questions were about model choice, framework choice, latency, and cost-per-token. Through 2025, those questions moved into the background and a different set moved forward.
This is the agentic AI update that gets the least airtime in the press but matters most for anyone shipping. The buying conversation has moved from the model layer to the access layer. The teams making real progress are the ones whose answer to "can your agent reach our systems" is something other than a multi-year API rebuild.
There's a debate running through engineering teams right now that hasn't been settled, and probably won't be in 2026. It's the question of how agents should access systems whose APIs don't expose what their UIs do.
Four approaches are in play:
None of these are settled best practice yet. What's increasingly clear is that browser automation hits a ceiling fast in production, and bespoke-per-product hits a ceiling fast at portfolio scale. The interesting work in 2026 is going to be in the third and fourth approaches — and in honest comparisons between them rather than vendor pitches dressed up as analysis.
A year ago, "agent-ready" was a marketing word. Through 2025 it started to mean something specific. A platform is agent-ready when its agents can reach the same surface its users can, with the same permissions, the same audit trail, and stable contracts that don't break silently when the product ships a new version.
That definition has consequences. It means agent-readiness is now a real commercial differentiator in enterprise SaaS. It means RFPs are starting to include questions that didn't exist eighteen months ago — about which workflows agents can complete, about how identity propagates from end user through agent through tool call. It means the gap between platforms that can answer those questions and platforms that can't is widening into something a CPO has to worry about.
The state of agentic AI in 2026 is, in one sentence: the model layer is ready, the protocol layer is ready, and the tools layer is where the next two years of real progress will happen.
The through-line of the last twelve months is that agent projects don't stall on the model. They stall at the access layer — the gap between what a product's UI can do and what its API exposes. That's the problem Tools-as-a-Service was built for.
Pontil generates tools from the codebases that already run your products. The contract is your API. Maintenance is automated as your product changes. Tool calls execute as the authenticated user, so permissions and audit trails honour the real identity rather than a shared service account. No rewrite, no bespoke connectors, no waiting on a foundation model provider's roadmap.
If the agentic AI update that matters to your team is "our agent project stalled when we tried to scale it past one product," that's the conversation we want to have.
Three things will tell us whether the field is making real progress or just generating more demos.
First, watch deployment depth, not pilot count. The number of companies running agent pilots is already saturated. The interesting metric is how many of those pilots reach more than one product, more than one workflow, and more than one team. That number is currently low. If it stays low through 2026, the Gartner cancellation forecast becomes the headline story of the year.
Second, watch what enterprise security teams accept. Identity propagation, per-user permissions, and audit trails are the questions that gate production deployment in regulated industries. The vendors and approaches that have credible answers there will pull ahead; the ones that rely on shared service accounts will hit a wall.
Third, watch the tools layer specifically. The next genuinely interesting agentic AI updates won't come from a new model release or a new framework. They'll come from how the industry solves the problem of building, maintaining, and governing the millions of tools agents will need to actually do useful work inside enterprises. That's where the bottleneck is now. That's where it will stay until someone solves it properly.
Stay up to date on the ever changing agentic landscape.
GET STARTED
Start with a 30-minute discovery call
contactus@pontil.com
