In the second iteration of the AI Agent Development Tools report, I replaced the integrability axis with enterprise-readiness. I wanted this to signify the departure from 2020-style IPaaS. With MCP getting traction to the point where every vendor offers an MCP server, I said the integration burden now lies with the server providers. They load the tools, definitions, manage schemas, access, and whatever. Your agent just needs to authenticate to the server and that’s it. The whole spiel with IPaaS was that managing however many API endpoints across their lifecycle was a headache, but you can buy this tool that makes it just a drag-and-drop exercise. But we’re not really doing that anymore (I’m speaking in relative terms). So bye-bye integrations axis, nobody wants you anymore. But wait! I regularly have vendor briefings, often with agent products of some kind. They all said “we integrate with your agent tool of choice”. They didn’t call them APIs, they were using hooks, SDKs, and obviously MCP. So integrations are taking a different shape compared to Zapier GET user_1 from MongoDB. Now I want to revisit integrations with this agent-first mindset and see what conclusions we get to. MCP et Le burden de configuration In the old API world, the burden sat squarely on the client side. The provider's job was to expose their product’s functions via a set of endpoints to a reasonable degree of comprehensiveness and document those so customers know what the hell to do with them. Everything after that (auth flows, retries, data mapping, keeping up with breaking changes) was the API consumer's problem. The client carried the burden, and carried it repeatedly, once per integration. This is why the IPaaS became a market, it grew up to absorb the client-side cost of wiring N systems to M others. Today, instead of consumers integrating against exposed APIs, providers publish an MCP server, and the client autonomously decides when and how to call it. MCP genuinely does rewrite part of this contract. A server exposes capabilities through a standardized protocol, like tools for actions, resources for context, prompts for templates, while a host application spins up a client per server to hold the connection, over stdio locally or streamable HTTP remotely. Short end of the stick for vendors. They deal with versioning it against a fast-moving spec, handling discovery, securing the transport. Keeping the server current is tough. For example, recent revisions made the protocol stateless with per-request capability discovery, and features get deprecated between versions. Happy days for consumers, they just discover what's available and the model decides when to use it. So yes, a real chunk of burden moved to the publisher: if you want your service usable by agents, you now stand up and maintain a server. APIs get facelifts At the end of the day, MCP is just an API wrapper. It recommends OAuth for obtaining tokens over its HTTP transport, and the spec formally points at OAuth 2.1 as the authorization mechanism for clients to get scoped access to servers. So MCP can only do what it does because APIs are getting updates. REST itself has a whole bunch of facelifts, including GraphQL’s spec refresh, gRPC for high-performance internal microservices, and HTTP/3 or QUIC are much faster. OpenAPI 3.1.1 finally reached full JSON Schema alignment, which matters enormously for agents, because it means a model can parse a specification accurately. New standards like Arazzo and OpenAPI Overlays describe multi-step workflows and layer policy onto specs without rewriting them. On security, APIs are hardening specifically against non-human actors. For example, demonstrating proof of possession (DPoP), token binding against replay, rich authorization requests for fine-grained scopes, financial-grade API profiles, dynamic rate limiting and behavioral analysis aimed at agents that can generate thousands of requests a second. I knew about kernel hooks but wasn’t sure if this is the same thing. These are deterministic scripts the harness runs at a fixed point in the agent loop (session start, prompt submit, before a tool call, after it, turn end). If an agent wants to call a tool, a hook triggers first and sends a POST request to a service to get a verdict back with a yes/no. Or the hook runs a local shell script or binary (like Python or Bash) on your machine, passing context via stdin and returning exit codes Hook configuration is a JSON file in the project and the harness talks to the hook over stdin/stdout. Claude Code hooks can fire in three cadences: once per session (SessionStart, SessionEnd), once per turn (UserPromptSubmit, Stop, StopFailure), and on every tool call (PreToolUse, PostToolUse). Hooks are the responsibility of security or platform teams. They’re a cheap and straightforward way to plug in a deterministic policy in an otherwise non-deterministic agent flow. They offer a centralized audit trail streaming every tool call to a SIEM, and a way to kill an agent process mid-run when the model misbehaves like a bad little agent. Other than hooks, you can integrate tools or processes into your own application code. Even though a lot of providers now expose their products via MCP servers, a growing share of integration in serious agent applications gets bundled with the application. The Claude Agent SDK is the clearest example. You can register an MCP server three ways: as a local process that talks over stdin/stdout, as an HTTP/SSE service for cloud-hosted servers and remote APIs, or as an SDK MCP server defined directly inside your application. That third option means that instead of standing up a separate server process, you define custom tools in the same codebase as the agent, and they connect as soon as the SDK processes the initial request. Subagents extend the same logic. The developer composes agent instances via an agents parameter or markdown files in .claude/agents/. They then isolate their context, run them in parallel, and restrict each one's tools so a doc-reviewer gets only Read and Grep and can't touch anything else. Decisions like what to embed, how to compose it, which tools to allow now landed on the application developer desk. In this respect, integration became a coding concern, which unintentionally landed quite well when I moved integrations under Codability. n8n integrations in 2026 Integrating third-party products is no longer a single-lane exercise. This includes MCP as well - I see devs and vendors solely focusing on MCP servers and their skills, whilst forgetting about APIs. As a provider, you will unfortunately have to juggle all the integration avenues. While it’s reasonable to expect an increase in the absolute number of MCP tools calls, the share of MCP vs API, Hooks, SDKs will become more balanced. Economics dictate that you won’t be able to tokenmaxx every tool call, and will be better off reverting to simpler tools, like APIs. Regardless, this is the CTA section, so if you want a whole bunch of API integrations, an SDK, MCP servers, or hooks, n8n’s got you covered. Share with us n8n users come from a wide range of backgrounds, experience levels, and interests. We have been looking to highlight different users and their projects in our blog posts. If you're working with n8n and would like to inspire the community, contact us 💌
AI NEWS JOURNAL
n8n 官方博客AI NEWS / JOURNAL
AI made integrations the vendor’s problem
In the second iteration of the AI Agent Development Tools report, I replaced the integrability axis with enterprise-readiness. I wanted this to signify the departure from 2020-style IPaaS. With MCP getting traction to the point where every vendor offers an MCP server, I said the integration burden now