I have spent most of my career in API-to-API integration. I built two enterprise integration and automation platforms, both since acquired, so I have lived the work of getting systems to talk to each other.
Here is what that work used to mean. Every integration was its own project. Getting our technology to speak to a third-party system took extensive engineering to build, and once it was built, we owned it. Every change on the other side was ours to absorb. The way two systems worked together was never trivial to establish, and it never stopped needing attention.
That is why I am genuinely excited about what we shipped in the late spring platform update.
One protocol instead of a pile of connections
The Nexadata MCP Server lets the platform operate in a headless, agent-driven way, interacting with a fast-growing list of technologies through a single open protocol, the Model Context Protocol, instead of a pile of one-off integrations.
Build to MCP once, and the ecosystem plugs in.
That is the part worth sitting with. The old arithmetic of integration was multiplicative: every new system on either side meant another project, another thing to own, another surface to maintain. A common protocol collapses that. The work of connecting stops scaling with the number of systems.
Three parts of the release make that real.
- The MCP Server exposes your workflows, pipelines, and execution telemetry to agentic AI clients.
- Runtime variables let an external agent inject values when it triggers a workflow, so one pipeline serves many requests.
- Execution statistics give per-run metrics, in the UI and through the server, so an agent and a person can both see exactly what a run did.
The same update also brought enhanced Excel support, with precise region targeting and dynamic range detection, alongside the usual run of platform improvements and fixes.
The connection stops being static
Because an LLM sits on top, reasoning against live workflows and execution history, the way systems work together is no longer fixed at the moment someone built it. It adapts.
That is the difference I did not have available in any previous platform I worked on. Before, the behavior of an integration was whatever we coded, until we coded something else. Now the reasoning layer can look at what is actually running and what has actually happened, and adjust how the work gets done.
Nexadata still does the work deterministically. The model reasons about intent; the engine executes; raw data never leaves the platform. The reach changes. The boundary does not.
Old school and new school
Old school: build and maintain a custom integration for every pair of systems.
New school: speak MCP once, and the reasoning layer makes the way systems work together smarter over time.
I spent years building integration the hard way. Watching the surface area for what can connect expand this fast, and this openly, is incredibly rewarding.
More on the architecture on the platform page, and on the data boundary on the security page.