Back to vendors
S

Solo.io

Also known as: solo.io, Solo.io, Inc., Solo Enterprise for kagent, Solo Enterprise for agentgateway, kagent, agentgateway, agentregistry

Visit site
Entry priceOpen source projects are free; Solo Enterprise pricing is quoted per environment.Full pricing detail

Solo.io sells Solo Enterprise for agentic infrastructure, built on open source projects it started and donated: kagent runs AI agents, MCP tools and skills as Kubernetes resources with memory, tool approvals and tracing, agentgateway carries LLM, MCP and A2A traffic through one gateway, agentregistry catalogs approved MCP servers, agents and skills, and agentdesktop watches agents on employee machines. Everything runs in the customer's own clusters, and enterprise subscriptions are quoted per environment.

Solo.io is a cloud native software company founded in 2017 that made its name on Istio service mesh and Envoy based API gateways, now sold as Solo Enterprise for Istio and kgateway. Its newer line, Solo Enterprise for agentic infrastructure, packages four projects for running AI agents in production: kagent, agentgateway, agentregistry and agentdesktop. Solo created kagent and agentgateway and donated them to open source foundations, and the free versions remain available alongside the enterprise editions. Logos on its site include Snyk, T-Mobile, BMW, Vonage, ADP, Carfax, Grainger and Pega.

kagent treats agents, tools and skills as Kubernetes custom resources. A team declares an agent with a system prompt, a model configuration and a list of MCP tools, and kagent runs it in the cluster with a dashboard, a CLI and a built in tool server for Kubernetes operations. Agents built in LangGraph, CrewAI or Google ADK can be brought in and governed the same way, and every agent speaks A2A, so other agents, Slack, Discord or Telegram can call it. Listing a tool under requireApproval pauses the agent with Approve and Reject buttons before the call runs, and a built in ask_user tool lets it put questions to a person.

Memory stores learnings and preferences as vectors in Postgres, keyed by agent and user, with a 15 day default lifetime that can be changed and an API to list or delete them. Models come from OpenAI, Anthropic, Gemini, Vertex AI, Azure OpenAI, Azure AI Foundry, Amazon Bedrock, Ollama, SAP AI Core, xAI or any OpenAI compatible endpoint. agentgateway proxies model, MCP and A2A traffic with model aliasing, token weighted rate limits, failover, prompt guards and MCP federation, and agentregistry holds approved MCP servers, agents, skills and prompts.

The open source projects are free. Solo Enterprise subscriptions have no public price list and are scoped by environment, number of clusters and support needs, so every quote comes through sales. The enterprise kagent adds agent identity with on behalf of token exchange, access policies, RBAC, OIDC sign in, mTLS, approval workflows and OpenTelemetry tracing of every agent action and tool call. Solo's trust center lists SOC 2 Type 1 and Type 2 reports, penetration test summaries and a CAIQ questionnaire. Because the software runs in the customer's own Kubernetes clusters, in any cloud or region and across several clusters, the customer decides where agent data lives.

Solo.io fits platform engineering teams that already run Kubernetes, and often Istio, and want one governed runtime and gateway for agents built in many frameworks, with identity, policy and tracing applied the way they are for other workloads. It fits less well for teams without Kubernetes skills, for buyers who want a hosted service with a self serve price, and for teams that need scored evaluation of agent output, which the documentation does not cover.

Vendor details

Canonical URL

https://www.solo.io

Category

Agent infrastructure

Subcategory

Kubernetes native agent runtime, AI and MCP gateway and agent registry, open source with enterprise editions

Funding status

Privately held. Solo.io, Inc. was founded in 2017; no funding rounds are named on the pages read.

Company status

independent

Use cases & customers

Primary use cases

running agents, MCP tools and skills as Kubernetes resources with identity and policyrouting and securing LLM, MCP and A2A traffic through one gateway with rate limits and failoverrequiring human approval before agents create, change or delete resourceskeeping a governed registry of approved MCP servers, agents, skills and promptstracing every agent action and tool call with OpenTelemetry

Target customers

platform engineering teams running agents on Kubernetesenterprises standardizing on Istio or Envoy that need governance over LLM, MCP and A2A trafficsecurity teams that need agent identity, access policy and audit over every tool callSRE teams building Kubernetes operations agents

Deployment options

Self hosted in the customer's own Kubernetes clusters, any cloud or on premisesMulticluster deploymentsOpen source editions installed with HelmLocal development with the kagent CLI and Docker

Integrations

kagent connects to models from OpenAI, Anthropic, Gemini, Google Vertex AI, Azure OpenAI, Azure AI Foundry, Amazon Bedrock, Ollama, SAP AI Core, xAI and any OpenAI compatible endpoint, runs agents built with LangGraph, CrewAI and Google ADK, and reaches Slack, Discord and Telegram over A2A. Tools come from MCP servers, including a built in tool server for Kubernetes operations, and kmcp builds and deploys new MCP servers in Python, Go, Java or TypeScript. Traces export over OpenTelemetry to tools such as Jaeger, and agentgateway sits in front of model providers and MCP servers.

In practice

A platform team declares a troubleshooting agent in kagent with the built in Kubernetes tools, letting it read pods, logs and events freely while listing apply, patch and delete under requireApproval. When the agent proposes restarting a failing deployment, an engineer reviews the YAML in the dashboard and clicks Approve.

A bank routes every team's model calls and MCP traffic through agentgateway in its own clusters, aliasing models so teams can switch providers, applying token weighted rate limits per team and federating approved MCP servers behind one endpoint with OAuth.

An internal developer platform team publishes approved MCP servers, agents and skills in agentregistry, then runs agents written in LangGraph and CrewAI on kagent so each one gets the same identity, access policy and tracing in Jaeger, regardless of framework.

Agentic Index coverage score

11.0 / 14 capabilities · 79%

Integrations & Tool Calling Full

Agents in kagent call tools from any MCP server, declared on the agent as a remote MCP server with the exact tool names it may use, and the built in tool server can apply manifests, patch and delete resources in the cluster as well as read pods, logs and events. kmcp scaffolds, builds and deploys new MCP servers in Python, Go, Java or TypeScript as Kubernetes resources, with secrets synced from a local env file. agentgateway federates many MCP servers behind one endpoint with OAuth, so each agent reaches outside systems under one access policy.

Sourcekagent.dev/docs/kagent/0.x/examples/human-in-the-loopread 2026-11-09

Workflow Orchestration Full

One kagent agent can call another as a tool: a coordinator lists a PromQL agent, or any other Agent resource in the same namespace or another, under its own tools and hands it work in the middle of its tool loop.

Calls to a subagent share one session by default for continuity, and an isolateSessions setting gives each call a fresh session so a coordinator can fan the same worker out in parallel.

Every agent also exposes an A2A endpoint for outside callers, teams can run LangGraph, CrewAI or Google ADK flows under kagent's governance, and an Agent Harness keeps a long running remote environment alive for extended work.

Sourcekagent.dev/docs/kagent/0.x/concepts/agents.mdread 2026-11-09

Knowledge Grounding & RAG Partial

Grounding an agent in documents is a pattern rather than a managed service. A kagent guide crawls a documentation website, stores the content in a vector store and gives an agent a tool to query it, and agentgateway labs show retrieval and semantic caching at the gateway. Skills add written guidance agents load as needed. There is no built in knowledge base with connectors to wikis, drives or ticket systems, so a team assembles retrieval from MCP tools and its own vector database.

Sourcekagent.dev/docs/kagent/0.x/llms.txtread 2026-11-09

Human Oversight & Guardrails Full

Any tool listed under requireApproval on an agent pauses the run before it executes, showing the proposed call, such as the YAML about to be applied, with Approve and Reject buttons in the dashboard. A rejection carries the person's stated reason back to the model so it changes course, read only tools run freely, and every agent has a built in ask_user tool for clarifying questions. Solo Enterprise adds approval workflows, review checkpoints and escalation paths, and agentgateway applies prompt guards to model traffic.

Sourcekagent.dev/docs/kagent/0.x/examples/human-in-the-loopread 2026-11-09

Security, Identity & Governance Full

Solo Enterprise for kagent gives every agent a verifiable identity and governs each action by access policy, with on behalf of semantics and token exchange so an agent acts with a user's rights, plus RBAC, OIDC and OAuth sign in and mTLS between agents and tools. MCP servers can be secured with OAuth at agentgateway, and agentregistry holds an approved catalog with provenance checks. Solo's trust center lists SOC 2 Type 1 and Type 2 reports, redacted penetration test summaries, a CAIQ Lite questionnaire and its security policies.

Sourcetrust.solo.ioread 2026-11-09

Observability & Auditability Full

Every agent action, tool call and decision path is traced with OpenTelemetry, which kagent starts and propagates on its own, so a run can be followed end to end in Jaeger or another tracing backend. Prompt auditing records every input and reply from each agent, sessions can be listed by ID from the CLI and opened in the dashboard, and the enterprise edition adds visual tracing of agent behavior. agentgateway adds end to end tracing of model and MCP traffic across teams, so one view covers the agent, its tools and its model calls.

Sourcekagent.dev/docs/kagent/0.x/llms.txtread 2026-11-09

Memory & State Persistence Full

Agent memory saves user intent, key learnings and preferences every fifth message as vectors in the kagent Postgres database, with timestamps and the source session, and pulls the closest matches into context before each reply. Memories are scoped to an agent and a user, expire after 15 days by default with ttlDays to change it, and can be listed, searched or deleted for one agent and user through the API or viewed in the dashboard. Agents also get save_memory and load_memory tools, and the embedding model is chosen separately from the main model.

Sourcekagent.dev/docs/kagent/0.x/concepts/agent-memoryread 2026-11-09

Deployment & Data Residency Full

kagent, agentgateway and agentregistry install with Helm into the customer's own Kubernetes clusters, in any cloud, region or data center, and the enterprise editions add multicluster operation with high availability. Agent sessions, memories and configuration sit in a Postgres database the customer can point at its own instance, and model calls go to whichever provider and region the customer configures, including local models through Ollama. Solo does not host the runtime, so the buyer decides where every piece of agent data lives.

Sourcekagent.dev/docs/kagent/0.x/concepts/agent-memoryread 2026-11-09

Prebuilt Agents / Templates / Packs Full

kagent's public Agents Registry carries ready made agents a team installs and runs as they are or adapts: a Kubernetes agent, a Helm agent, an Istio agent, a kgateway agent, an observability agent that queries Prometheus and builds Grafana dashboards, a PromQL agent, a Cilium network policy agent and an Argo Rollouts converter, beside a catalog of MCP enabled tools. agentregistry gives an organization its own catalog of approved MCP servers, agents, skills and prompts to publish and reuse, and the kagent CLI scaffolds new agent projects for several frameworks.

Sourcekagent.dev/agentsread 2026-11-09

Triggers & Channel Coverage Partial

Work reaches a kagent agent when someone or something calls it: a chat in the dashboard, the kagent invoke command, an A2A client, the MCP server that exposes running agents, or a bot in Slack, Discord or Telegram connected over A2A. That covers the places people already talk to their infrastructure. No schedule, cron resource, webhook listener or cluster event watcher starts an agent on its own, so a recurring health check or an alert driven run needs an outside scheduler or alerting system to call the agent.

Sourcekagent.dev/docs/kagent/0.x/llms.txtread 2026-11-09

Model Flexibility & Routing Full

Each kagent agent points at a ModelConfig the team defines, with routes to OpenAI, Anthropic, Gemini, Google Vertex AI, Azure OpenAI, Azure AI Foundry, Amazon Bedrock, Ollama, SAP AI Core, xAI or any OpenAI compatible endpoint, and memory can use a different embedding model. Requests can also run through agentgateway, which adds model aliasing, token weighted rate limits, failover between providers and routing rules, so a platform team can switch a model for every agent without editing them.

Sourcekagent.dev/docs/kagent/0.x/llms.txtread 2026-11-09

APIs / SDKs / MCP Extensibility Full

Agents, tools, model configurations and MCP servers are Kubernetes custom resources with a published API reference, so teams manage them with kubectl, Helm or GitOps. The kagent CLI installs, initializes, builds, deploys and invokes agents and MCP servers, REST endpoints manage sessions and memories, and the control plane runs an MCP server that exposes every running agent to outside clients. Every agent also implements A2A, so other agents and applications can call it directly.

Sourcekagent.dev/docs/kagent/0.x/llms.txtread 2026-11-09

Testing, Debugging & Optimization Not documented

kagent has no evaluation harness, scored test set or quality gate in its documentation. Local development runs an agent project in Docker Compose for an interactive chat before deploying it, and the debug guide covers agents that fail to start or answer. Solo's marketing graphics list evaluation among agent capabilities and a blog post describes an agentevals benchmarking project, but no product page or guide shows how a team scores an agent's answers or blocks a release on them.

Sourcekagent.dev/docs/kagent/0.x/llms.txtread 2026-11-09

Browser / Computer-use Not documented

kagent agents do not drive a browser, desktop or remote computer. They act through MCP tools and Kubernetes APIs, and Agent Substrate runs agents and stateful workloads in sandboxed pods, which isolates execution without operating a screen. agentdesktop watches and secures the agents employees run on their own machines, giving visibility and control over them rather than letting an agent click through desktop applications.

Sourcesolo.ioread 2026-11-09

The Agentic Index coverage score grades every vendor Full, Partial or Not documented against the same 14 buyer facing capabilities, from public evidence only. Each capability links to how all vendors in the index score on it. How this evidence is graded

Pricing

Open source projects are free; Solo Enterprise pricing is quoted per environment.

Enterprise subscription scoped to the customer's environments, number of clusters and support needs

Free tier

Included quota

No published quotas. The open source editions have no usage limits set by Solo.

What is public

That the open source projects are free and that enterprise pricing is scoped to environments, clusters and support.

Billing mechanics

Enterprise subscriptions are contracted through sales after an estimate request.

Cost watchouts

Running the software means paying for the Kubernetes clusters, Postgres with pgvector for memory, tracing backends and model usage on the customer's own accounts.

Variable cost rationale

The subscription is negotiated, and the software runs in the customer's own clusters, so the variable costs are the customer's own compute and the model providers it chooses rather than Solo metering.

Additional watchouts

Enterprise only features such as agent identity, approval workflows and visual tracing need a quote before a team can price them.

Overage / add-ons

Not applicable; enterprise terms are set per contract.

Sales call required

Yes, required for paid access

Free / trial

The open source agentgateway, kagent, agentregistry and kgateway projects are free to use.

Lowest paid plan

No public paid plan. Solo Enterprise subscriptions are quoted by sales.

Commercial notes

Solo started kagent and agentgateway and donated them to open source foundations, and sells enterprise editions with identity, policy, tracing and support on top.

Key ambiguities

No published price, tier list or feature split between free and enterprise editions on the pricing page, beyond the enterprise product pages' feature lists.

Support SLA / resale

Enterprise subscriptions include paid support; security fixes are announced to customers on paid support first.

Missing data

All enterprise prices, contract terms and the feature split between editions.

Agentic Index verified 2026-11-09

Alternatives to Solo.io

The closest documented capability profiles to Solo.io among agent infrastructure platforms tracked by Agentic Index, ordered by similarity on the same 14 point evidence the rankings use. No vendor pays for placement.

  • AlphaBitCore9.5 / 14A lighter documented profile than Solo.io
  • Kestra12.5 / 14Adds documented Testing, Debugging & Optimization
  • Agno13.0 / 14Adds documented Testing, Debugging & Optimization
  • Haystack12.0 / 14Adds documented Testing, Debugging & Optimization
  • LlamaIndex12.0 / 14Adds documented Testing, Debugging & Optimization
  • Redwood Software11.0 / 14Adds documented Testing, Debugging & Optimization

Similarity is computed from each vendor's Agentic Index coverage score evidence, axis by axis, not from the totals. How this evidence is graded

Contact us

Found a vendor we missed? Have feedback on the index? We'd love to hear from you.