Last week, the agentic AI community came together in Amsterdam for AGNTCon + MCPCon Europe, bringing developers, open source maintainers, platform teams, and infrastructure builders together around a rapidly evolving question: what does it take to move AI agents from interesting experiments to systems that can operate reliably in the real world?
For Solo.io, the event was an opportunity to share what we're building across agentic infrastructure, but just as importantly, to listen.
From conversations at our booth and hands-on labs to sessions with the broader community, a few themes came through clearly. Teams are moving beyond experimenting with individual agents and starting to think about the infrastructure, security, governance, and operational models required to support them at scale.
Agents are moving out of the sandbox
One of the biggest shifts we heard was a growing focus on what happens after an agent works in a demo.
Developers are experimenting with coding agents, MCP servers, multi-agent workflows, and autonomous systems. But as those systems become more capable, the infrastructure questions become harder.
Where does an agent run? How does it get access to tools and data? How do you control what it can do? How do you know which user or workload initiated an action? And how do you manage the resources required when agents can start, stop, and scale dynamically?
These aren't questions that can be solved by the agent framework alone. They require infrastructure that understands the unique characteristics of agent workloads.
That is the problem space Solo has been focused on with projects including agentgateway, kagent, Agent Substrate, and agentdesktop.
MCP is becoming infrastructure, not just a developer protocol
MCP was everywhere at the event, but the conversations are increasingly moving beyond simply connecting an agent to a tool.
As organizations connect more MCP servers and expose more capabilities to agents, the infrastructure around those connections becomes increasingly important. Teams need ways to authenticate and authorize requests, manage identities and credentials, observe traffic, control access to tools, and avoid overwhelming agents with huge catalogs of available capabilities.
We saw this firsthand in the hands-on interest around our agentgateway labs, where attendees explored everything from federating MCP servers to using search and code modes to manage tool discovery and context.
The underlying question is changing from “How do I connect my agent to an MCP server?” to “How do I operate MCP safely and efficiently across an organization?”
That's a meaningful shift.
Learn more about MCP in the on-demand workshop, "MCP: From Zero to Production."
Agent infrastructure can't assume Kubernetes is the only place agents run
Another recurring theme was the diversity of environments in which agents are being deployed.
Kubernetes remains an important foundation for running AI workloads, particularly for platform teams operating agents at scale. But not every agent starts there. Developers are running AI tools locally. Teams are experimenting with VMs and other compute environments. Managed services and other runtimes are increasingly part of the picture.
That reality was reflected in one of our major messages at the event: agentgateway is now for any runtime.
The goal is to provide consistent connectivity, security, authentication, authorization, and governance for agent, MCP, A2A, and inference traffic regardless of where an agent happens to run.
And that same principle applies on the developer desktop.
With the introduction of agentdesktop, we're extending visibility, identity, policy, and management to the place where many AI tools actually begin: the developer's laptop. Teams can discover AI tools, MCP servers, skills, and models across their fleet and apply policies and credentials centrally.
Running agents efficiently is becoming its own infrastructure problem
We also heard growing interest in the operational characteristics of agents themselves.
Traditional workloads tend to have relatively predictable resource patterns. Agents can behave very differently. They may need significant resources for a short period, sit idle while waiting for input, or spin up dynamically in response to demand.
That creates a different set of infrastructure requirements.
At the event, we demonstrated how Agent Substrate and kagent can work together to run agents with faster startup, efficient resource utilization, and isolation, giving teams a way to think about agents as a distinct workload rather than simply another long-running Kubernetes deployment.
The conversations reinforced something we've been seeing across the community: agent infrastructure needs to be designed around how agents actually behave.
The control plane is expanding
Perhaps the most interesting takeaway from Amsterdam was how many different layers of the agent stack are starting to converge.
An organization may need to:
- Build and manage agents
- Run agents efficiently and securely
- Connect agents to tools, APIs, models, and other agents
- Manage identity and authorization
- Govern MCP servers and tool access
- Manage AI tools running on developer machines
- Discover and manage agents and their capabilities
These aren't isolated problems.
They are connected parts of the infrastructure required to operate an agentic environment.
That's the thinking behind Solo's broader approach to agentic infrastructure: providing the connectivity, runtime, management, and governance layers needed to support agents throughout their lifecycle.
Open source is still where the interesting problems are being solved
AGNTCon + MCPCon Europe also reinforced the importance of the open source communities building this ecosystem.
The event brought together maintainers, developers, researchers, and platform engineers working on the protocols, runtimes, tools, and infrastructure that will shape how agents operate.
For Solo, that community participation is central to how we build. Projects such as agentgateway, kagent, agentregistry, and kgateway are part of a broader open source ecosystem, and the feedback we get from developers using these projects directly influences where we invest next.
Our booth and hands-on labs made that particularly tangible. Instead of simply talking about agentic infrastructure, attendees could get hands-on with MCP, agent skills, kagent, agentregistry, and agentgateway. Check out more labs here.
What's next?
The conversations in Amsterdam made one thing clear: the agent ecosystem is moving quickly, but the infrastructure underneath it is still being built.
The next phase won't just be about making agents more capable. It will be about making them operable, secure, observable, governable, and efficient in environments where real users, real data, and real business processes are involved.
That's the work we're excited to be part of.
From the developer desktop to Kubernetes and other runtimes, from MCP and A2A connectivity to agent execution and resource management, Solo is building toward an infrastructure layer that can support agents wherever they run and whatever they need to connect to.
Want to go deeper? Here are a few ways to explore the work happening across the ecosystem:
- Build with agentgateway: Explore the open source agent gateway for connecting and securing agent, MCP, A2A, and inference traffic across runtimes. Learn more about agentgateway.
- Build and run agents with kagent: Get hands-on with kagent, the open source project for building, deploying, and managing AI agents on Kubernetes. Explore kagent.
- Explore agentregistry: Discover an open source registry for agents, MCP servers, skills, prompts, models, and other building blocks for agentic applications. Visit agentregistry.
- Try the hands-on labs: Put these ideas into practice with labs covering agentgateway, MCP, kagent, agentregistry, agent skills, and more. Explore the labs.
- Catch up on AGNTCon + MCPCon: Watch keynotes and technical sessions from the event to hear directly from the developers, maintainers, and infrastructure builders shaping the agent ecosystem. Watch the event keynotes on demand.
- Get involved: Try the projects, open an issue, contribute code, share feedback, or join the communities around the open source projects. The ecosystem is still taking shape, and there is plenty of room to help shape what comes next.
The work is still underway. The best way to understand where agentic infrastructure is headed is to build with it, test it, challenge it, and contribute to the communities building it.
%20(1).png)
%20a%20Bad%20Idea.png)
