Enterprise MCP Bridge: From Local Tools to Global Minds
With versions v0.2.0 and v0.2.1, the Enterprise MCP Bridge grows up. What started as a REST-Facade for your beloved MCPs, has been turning into something more over the past few releases: a distributed platform for intelligent coordination. These easily created mcp-agents can now reach across remote MCP servers with integrated token management, plan their work through todo-driven reasoning, and start to look less like scripts and more like collaborators. And you can still use it as before - just like we do internally at INXM, a thing we have been way to secretive about, but worry not, we will share much more soon!
Remote MCP Repositories: The End of Local Isolation
Let’s start with the big one: remote MCP server support.
You can now connect remote MCP servers and let agents discover and use them as if they were local. A model in one data center can now tap a service hosted halfway across the world, without custom integration work - and all with the previously built-in authentication/token management and the observability features you would love to have in your other platforms.
This shift isn’t just technical - it’s architectural. It hints at a future where agents don’t belong to a single environment but roam across trusted MCP networks. The bridge now acts as the federation layer between silos, enforcing authentication, caching intelligently, and doing all the boring-but-crucial bits that make distributed intelligence actually work. And you can manage all the connections centrally through your own IT, filtering the available tools and auditing everything that happened.
Todo-Based Planning: When Agents Learn to Think in Lists
The second new capability - todo-based planning - might look humble on the surface. But this one changes how agents reason.
Agents can now plan through structured todo lists. Not the static kind you forget in your notebook, but dynamic, self-adjusting task graphs. The bridge understands todos as actionable, contextual units: things that can be decomposed, tracked, and completed. It’s a foundational step toward autonomous planning, one that you might have seen in other products already.
In practice, this means your agent no longer just executes instructions - it organizes its own work. It can decide what to do first, what depends on what, and what’s blocked. More importantly, you can see it happen. Each todo is a window into the agent’s reasoning. Planning through todos might sound trivial, but anyone who’s worked with multi-step agents knows how brittle improvisation can be. This change introduces a more consistent, inspectable framework for goal-driven workflows - turning lists into logic.
Note that this will happen only if you don’t provide a single, predetermined tool call. If you do provide a tool the agent must call, the agent will execute it directly without generating a todo list.
The Rest of the Iceberg
The releases also bring a wave of polish and refinement:
Caching and lifecycle management have been overhauled. Connections now keep state predictably across sessions, cutting latency and drift.
Observability got a boost. Logs are cleaner, and debugging multi-agent interactions finally feels like you’re not spelunking through chaos.
SDK ergonomics have improved across the board, especially for developers embedding the bridge in locally hosted environments or Claude.
Configuration is simpler, less fragile, and (hopefully) clearer documented.
These improvements reflect our commitment to quality. With each update, the bridge transforms from a developer tool into robust, production-grade infrastructure you can depend on.
A Bridge That Thinks Beyond Itself
There’s a pattern here - one that’s easy to miss if you only look at the changelog. Every iteration of the Enterprise MCP Bridge pushes toward the same goal: reducing friction between intelligence and systems.
Remote MCPs let agents explore beyond local boundaries. Todo-based planning lets them reason about what to do once they’re there. Combined, they mark the moment where the bridge stops just connecting endpoints and starts connecting intent.
It’s not just a framework anymore. It’s a hint at what happens when you give structure to autonomy - and let distributed systems think together.
Feel free to dig dive deeper into the details and commits here:
Or check out the new remote MCP example that directly demonstrates these new capabilities by connecting to the remote Github MCP Server!