LATEST
AI Tools

kagent 1.0: AI Agents on Kubernetes, Without a Pod per Agent

Updated November 18, 2026
16 min read
Editor's Note: This article was human-reviewed for accuracy
High-tech server rack in a secure data center with network cables and hardware components

Quick Answer & Key Takeaways

  • • kagent 1.0 reached general availability on November 9, 2026, giving Kubernetes teams a free, open-source way to run AI agents without a dedicated Pod for each one.
  • • Agents run as sandboxed actors on Agent Substrate, suspend when idle, and resume on any free worker.
  • • The software costs nothing under an Apache 2.0 licence; the bill is your model provider's API usage, and enterprise support is quote-only.

Running AI agents on Kubernetes has a scaling problem that has nothing to do with the model. The model is the easy part. The hard part is that an agent spends most of its life waiting: waiting on the model, waiting on a tool, waiting on a human to answer. If every waiting agent holds a Pod, a thousand conversations become a thousand mostly idle Pods, each holding memory, CPU and an IP address while doing nothing. kagent 1.0, which reached general availability on November 9, 2026, is Solo.io's answer to that problem, and it is free and open source under an Apache 2.0 licence. Instead of one Pod per agent, it runs agents as sandboxed actors on a layer called Agent Substrate, suspends them when they go idle, and resumes them on any free worker when the next message arrives.

That is a meaningful change in how agent infrastructure works, and it arrives with production users already attached. OutSystems and Swissquote are running it in production, and the enterprise releases went generally available on November 10. This article explains what kagent 1.0 does, what it costs, how to set it up, and where it still falls short.

What kagent 1.0 actually is

kagent is an open-source platform for running AI agents on Kubernetes, built by Solo.io and now a CNCF project. Version 1.0 is the first release built on Agent Substrate, a separate CNCF project that Solo.io designed alongside Google. The split matters: Substrate is the low-level runtime that decides where an agent runs, and kagent is the layer on top that knows what an agent is for, who owns it, and who is allowed to talk to it.

The project started in January 2025, according to its GitHub repository, and it has gathered 4,425 stars and 928 forks as of November 18, 2026. The Agent Substrate repository has 7,487 stars. Those numbers measure attention, not reliability, but the direction is clear: agent infrastructure on Kubernetes is getting real investment, and kagent is one of the projects leading it.

An agent in kagent is defined declaratively, as three Kubernetes resources: a Harness (the runtime the agent runs in), an AgentTemplate (the model, system prompt, tools and skills), and an Agent (which ties the two together). You apply them with kubectl like any other workload. Models can come from OpenAI, Anthropic, Gemini, Vertex AI, Azure, Bedrock or Ollama, and kagent can also run Claude or Codex harnesses, or any container that speaks its A2A contract, with the same lifecycle, access controls and sandboxing.

Why a Pod per agent breaks

Before 1.0, kagent ran agents the way most teams still run them: as a Kubernetes Deployment, one Pod (or a set of replicas) per agent, the same pattern used for a microservice. Solo.io's announcement post explains why that pattern fails for agents, and the reasoning is worth repeating because it shapes the whole design.

First, the model decides what runs. Ask an agent to fix a document and it may write a shell command or a short Python script that nobody reviewed, shaped by whatever its context pushed it toward. That code is untrusted by definition, so each session needs a real sandbox with egress controls and safe credential handling. A plain container is not enough.

Second, state accumulates in the agent's workspace. An agent clones a repository, installs packages and edits files, so its environment is the work, and a restart, eviction or node drain throws that work away unless the state is preserved.

Third, agents mostly wait. A Pod holding CPU and memory for an agent that is waiting on a model or a person is a Pod doing mostly nothing, and a thousand such sessions is a fleet of idle Pods. Solo.io illustrates it with a grid of 10,000 sessions where only a few hundred are working at any moment. Tool sandboxes have the opposite problem: a Pod per tool call can spend more time being reconciled through the Kubernetes API server than actually running.

Fourth, identity does not travel with the session. One shared ServiceAccount cannot tell sessions apart for policy or audit, and once sessions start moving between Pods, an identity tied to the Pod cannot follow them.

How Agent Substrate fixes it

Agent Substrate separates the worker from the actor. The worker is a warm Pod in a WorkerPool that Kubernetes runs and scales. The actor is the agent session, with its own sandbox, state and durable identity, running on a worker. When an actor goes idle, Substrate snapshots its workspace and optionally its entire memory, then gives the worker back. When a request arrives for a paused actor, the router finds a free worker and restores the actor into it, holding the request briefly if no worker is free yet. None of this goes through the Kubernetes API server, which is why Solo.io says it is cheap enough to do on every turn or every tool call.

Security is the other half. Every actor runs in its own gVisor or microVM sandbox, and Substrate does not support plain containers at all. Each actor gets its own SPIFFE identity, which follows the actor from worker to worker instead of belonging to the Pod. Requests pass through an ingress router that authenticates the caller and checks policy before waking the actor. Everything going out passes through an egress gateway, and the sandbox holds no credentials: the gateway checks the request against the actor's policy and injects the API key or token on the way out, so a prompt-injected agent has nothing to steal. Both gateways run on agentgateway, which understands LLM, MCP and A2A traffic, so a policy can say which models, MCP tools or other agents an actor may call.

Kubernetes still does what it is good at here, running and scaling the worker Pods, and everything a team already knows about operating a cluster still applies. Substrate handles the part that changes too often for the Kubernetes control plane to keep up with. A sizing calculator on kagent.dev estimates wake-up times and the CPU, memory and storage a deployment needs, based on Solo.io's performance and scale testing for the 1.0 release.

What kagent adds on top of Substrate

Substrate is deliberately low level. Its own README calls it a low-opinion runtime, not an agent SDK. It has no concept of a user, a conversation or an agent, so it cannot tell an agent waiting on its user from one halfway through a tool call, and it does not know who owns a sandbox. kagent is the layer that answers those questions.

Bring your own harness: run kagent's own agent runtime, Claude, Codex, or any container that speaks kagent's A2A contract. Declarative agents: define an agent from a model, a prompt, MCP tools, skills and plugins, and reuse that definition across agents and harnesses. Safe rollouts: change a prompt or a model and new conversations pick it up, while conversations already in flight stay on the version they started with. Auto-suspend: every conversation suspends when its turn ends and resumes on whatever worker is free when the next message comes in, so an idle conversation holds no compute. Human-in-the-loop: an agent can stop and ask a person for approval, suspend at exactly that point, and pick up the same operation when they answer, with a webhook to tell your system it is waiting.

History, checkpoints and forks: conversation history is readable without waking a sandbox, you can checkpoint a conversation and fork a new one from it, and idle conversations clean themselves up after seven days by default. Users, ownership and sharing: people sign in through your OIDC provider, every conversation belongs to whoever started it, and kagent checks ownership before a request reaches an agent. No credentials in the agent: model API keys and MCP credentials are injected by the egress gateway and rotate without restarting anything, and everything else is denied unless an EgressPolicy allows it. Sandboxes on demand: people and agents can grab a short-lived sandbox to run a script or process files, and kagent can also act as the self-hosted sandbox for Claude Managed Agents, though that is experimental for now. Agents are reachable over A2A and MCP, kagent has its own MCP server for sessions, checkpoints and sandboxes, and there is a UI, a CLI, and OpenTelemetry traces, metrics and token usage across harnesses.

What it costs

The open-source software costs nothing. kagent and Agent Substrate are both Apache 2.0 licensed, and the open-source distributions are also listed on the AWS, Azure and Google Cloud marketplaces. What you pay for is everything around it: the Kubernetes cluster it runs on, and the model provider's API usage for every agent turn.

OpenAI is the default model provider in the install flow, and its current rates give a sense of the running cost. GPT-6.2 Sol, the cheaper of OpenAI's two new models launched November 17, costs $2 per million input tokens and $10 per million output tokens, with cached input at $0.10 per million tokens. At November 18, 2026 market rates, that is about £1.52 and C$2.86 per million input tokens, and about £7.60 and C$14.31 per million output tokens. GPT-6.2 Astra, the heavier model, costs $8 and $40 per million tokens on the same basis. Those are OpenAI's published rates, not kagent's, and your bill depends on which model you configure and how much your agents talk.

The enterprise releases of Agent Substrate and kagent are a different story: they went generally available on November 10, 2026, and Solo.io publishes no price for them. They add granular access control over agent resources, agent tracing and evaluations built from real execution traces, visibility into Substrate fleet capacity and failures, air-gapped installs, and support from the people building both projects. If you need those features, the price is a sales conversation, and the article cannot quote a number Solo.io has not published.

Cost itemPriceNotes
kagent 1.0 open source$0Apache 2.0 licence; self-hosted on your cluster
Agent Substrate 1.0 open source$0Apache 2.0 licence; CNCF project
Model usage (OpenAI default, GPT-6.2 Sol)$2 / $10 per 1M tokensInput / output; cached input $0.10 per 1M tokens; billed by OpenAI
Model usage (OpenAI, GPT-6.2 Astra)$8 / $40 per 1M tokensInput / output; cached input $0.40 per 1M tokens
Kubernetes clusterVariesYour cloud bill; workers scale with load, idle actors hold no compute
Enterprise releasesNot publishedQuote only; access control, tracing, evaluations, air-gapped installs, support

How to get started

You need a Kubernetes cluster running version 1.37 or later, Helm, and a model provider key. The 1.37 requirement is not arbitrary: Substrate uses certificate APIs that went generally available in that release, and Kubernetes 1.37 itself shipped on October 28, 2026, so a cluster provisioned in the last few weeks should qualify, while older clusters need an upgrade first.

Installation is one command sequence from Solo.io's announcement. First install the CLI, pinned to the 1.0 release:

curl -sL https://raw.githubusercontent.com/kagent-dev/kagent/refs/heads/main/scripts/get-kagent | bash -s -- --version v1.0.0
export OPENAI_API_KEY=<your key>
kagent install

The install sets up Agent Substrate, PostgreSQL and kagent in one step. The docs also offer a shorter installer at kagent.dev/install, and Helm charts directly for GitOps setups. If you are running kagent 0.x today, plan on a fresh install: 1.0 is a new API on a new runtime, not an in-place upgrade.

Your first agent is three resources applied with kubectl: a Harness, an AgentTemplate carrying the model configuration and system prompt, and an Agent tying them together. Check readiness with kagent agent get my-first-agent; READY should become True, and a False reading right after applying is expected while a runtime snapshot builds, which takes about a minute. Then create a session, which starts an actor on the WorkerPool, and invoke it over the A2A protocol:

export SESSION_ID=$(kagent agent session create --agent my-first-agent -o json | jq -r '.session.id')
kagent agent invoke --session $SESSION_ID --task "What is 2+2?"

The session keeps the transcript, so a follow-up in the same session can refer back to earlier turns. The docs walk through the full example, including the Harness, AgentTemplate and Agent YAML, at kagent.dev/docs/kagent/latest/get-started/your-first-agent/. Running bare kagent opens an interactive terminal workspace, and the CLI reaches the controller at localhost:8083, falling back to a kubectl port-forward against the kagent-controller service.

Who is running it in production

Solo.io names two launch customers. OutSystems runs a large multi-tenant platform, which is exactly the Pod-per-agent problem at scale, and uses kagent and agentgateway for the APIs, lifecycle management and gateway controls that plug agents into that platform. Its VP of Engineering, Ebenezer Schubert, said that with the number of agents they expect to support, running a dedicated, always-on Pod for every agent simply is not possible, and that Agent Substrate gives them sandboxed runtimes that suspend when idle and resume on demand.

Swissquote runs a sovereign AI stack, with full control over its inference, infrastructure and AI lifecycle, and uses Solo.io's enterprise releases for infrastructure-level isolation and security. Its Head of Information Technology, Andrew Boswell, said its Codename Diego financial-crime investigation agents and MCP servers are already running in production on kagent GA, and that in a multi-jurisdictional regulated environment, security, resilience and explainability are non-negotiable. Both quotes come from Solo.io's own announcement, so treat them as the vendor's evidence, not independent verification. The Substrate repository itself has 7,487 stars as of November 18, 2026, and the announcement credits more than 100 contributors from over 40 organisations.

The catches

The first catch is the hardware bar. Kubernetes 1.37 or later is a hard requirement, and many production clusters are not there yet. If your cluster is on 1.36 or older, kagent 1.0 is a cluster upgrade project before it is an agent project.

The second catch is the upgrade path, or the lack of one. Version 1.0 is a new API on a new runtime, and Solo.io says plainly that 0.x users should plan on a fresh install. Early adopters who built on the pre-1.0 releases will rebuild their agents rather than migrate them.

The third catch is evidence. The scale story, thousands of agents on tens of Pods, rests on Solo.io's own performance and scale testing, and the sizing calculator on kagent.dev is built from that testing. No independent benchmark of kagent 1.0 exists yet, and the production quotes come from the vendor's launch announcement. The architecture is sound on paper, and the sandboxing model is careful, but the numbers are Solo.io's until someone else measures them.

The fourth catch is enterprise pricing. The features production teams most often ask for, granular access control, evaluations built from real traces, air-gapped installs, are all in the enterprise releases, and Solo.io publishes no price for them. A team that needs those features cannot budget the project from public information.

The fifth catch is scope. kagent is infrastructure, not an agent builder. It gives you the runtime, the sandboxing and the lifecycle, but you still write the prompts, choose the models, connect the MCP tools and design the agent itself. Teams expecting a finished agent product will find a platform that assumes they already know what they want to build. Our AWS Infinity explainer covers a related idea, a runtime that suspends idle agents, from a different angle, and our OpenClaw review looks at the opposite end of the spectrum, a free assistant that runs on your own machine and that you control from WhatsApp.

kagent 1.0 vs the alternatives

Most teams running agents on Kubernetes today fall into one of three patterns, and kagent 1.0 is a direct answer to the first. The table below compares them on the dimensions that decide the choice.

ApproachHow agents runSandboxingIdle costPrice
kagent 1.0Sandboxed actors on Agent SubstrategVisor or microVM per actor; no plain containersIdle actors suspend and hold no compute$0 open source; enterprise quote-only
Agents as K8s DeploymentsOne Pod or replica set per agentPlain container unless you add it yourselfIdle Pods hold CPU, memory and an IP$0 software; you pay for idle capacity
Hosted agent runtimesVendor runs the loop; sandboxes on their infra or yoursVendor-managed; kagent can host Claude sandboxesPay per use or per seat, vendor termsVaries by vendor

The Deployment pattern is the simplest to start with and the most expensive to scale, because every waiting agent keeps a Pod warm. Hosted runtimes remove the infrastructure work entirely, but you give up control of where agents run and what they can touch. kagent 1.0 sits between them: you keep the cluster and the control, and the runtime handles the suspend, resume and sandboxing that make the Deployment pattern wasteful. If you already run Kubernetes in production and your agent count is heading into the hundreds, that middle ground is the case for trying it. If you run a handful of agents, the Deployment pattern is still simpler, and the 1.37 requirement alone may not be worth the upgrade.

Common mistakes

Treating a sandbox as optional is the first mistake. The whole point of Substrate is that agent-written code is untrusted, and the egress gateway is what keeps credentials out of the agent's reach. Running agents in plain containers on the same cluster, or handing an agent a real API key in its environment, defeats the design.

Skipping the EgressPolicy is the second. The gateway denies everything a policy does not allow, which means a new MCP tool or model endpoint fails closed until you add it. That is the safe default, but it reads as a broken integration if you do not expect it, so budget time for policy setup in any pilot.

Assuming the free tier covers the enterprise features is the third. Access control, tracing, evaluations and air-gapped installs are enterprise-only, and the open-source release does not include them. Check the feature split before committing to a production design that depends on one of them.

Upgrading a 0.x install in place is the fourth. Version 1.0 needs a fresh install on a new runtime, so plan the migration as a rebuild, with your agents redefined on the new API.

Frequently asked questions

Is kagent 1.0 free?

Yes, for the open-source release. kagent and Agent Substrate are both Apache 2.0 licensed and cost nothing to download and run. You still pay for the Kubernetes cluster and for your model provider's API usage, and the enterprise releases with access control, evaluations and support are priced by Solo.io on request.

What do I need to run it?

A Kubernetes cluster on version 1.37 or later, Helm, and a model provider key. OpenAI is the default provider in the install flow, but Anthropic, Gemini, Vertex AI, Azure, Bedrock and Ollama are supported. The install command sets up Agent Substrate, PostgreSQL and kagent in one step.

How is kagent different from Agent Substrate?

Agent Substrate is the low-level runtime: actors, workers, snapshots, sandboxes, identity and egress policy. It has no concept of a user, a conversation or an agent. kagent is the layer on top that adds users, conversations, agents, sandboxes on demand, checkpoints, human-in-the-loop approval and the UI and CLI. Substrate decides where an agent runs; kagent decides what it does.

Can I run Claude or Codex agents on kagent?

Yes. kagent supports bring-your-own-harness, including Claude and Codex, or any container that speaks its A2A contract, with the same lifecycle, access controls and sandboxing as its own runtime. It can also act as the self-hosted sandbox for Claude Managed Agents, though Solo.io marks that experimental for now.

What happens to my agents when I change a prompt?

New conversations pick up the change, while conversations already in flight stay on the version they started with. That makes prompt and model changes safe to roll out without interrupting users mid-conversation.

Is kagent 1.0 production ready?

Solo.io says yes, and names OutSystems and Swissquote as production users. The 1.0 release is a new API on a new runtime, so 0.x users need a fresh install. No independent benchmark exists yet, so the scale claims rest on Solo.io's own testing until third parties measure them.

kagent 1.0 solves a real problem, and it solves it in the right layer. Pods were designed for code you wrote and reviewed; agents run code a model wrote, keep state between turns, and spend most of their time waiting. A runtime that suspends idle agents, sandboxes every session, and keeps credentials out of the agent's reach is the infrastructure agent work has been missing on Kubernetes. The open-source release is free, the install is short, and the production users are real. The open questions are the ones that always follow a 1.0: independent numbers, enterprise pricing, and how the project holds up once thousands of teams, not two launch customers, are running it. If you already operate Kubernetes and your agent count is climbing, it is worth a pilot on a 1.37 cluster. Start with the docs at kagent.dev and the announcement at solo.io.

Sources

16 min read
35 views
edit_note Written by

Ratul Ahamed

Founder & Editor-in-Chief

Ratul Ahamed is the founder and editor of AI Core Updates, an independent site covering AI tools, models and pricing. He is a web developer based in Bangladesh and also runs All In One Tools, a free collection of browser-based utilities. Contact: [email protected]

Read all stories by Ratul Ahamed arrow_forward
verified_user Human-Reviewed Editorial

forum Comments (0)

Leave a Reply

chat_bubble_outline

No comments yet. Be the first to join the conversation!

Weekly AI Digest

Get our weekly AI tools digest

One email a week analyzing new AI tools, model updates, and practical workflows. Tested and summarized with zero fluff. Unsubscribe any time.

bolt
Hands-on AI Tool Reviews
Pricing math, limits, and alternatives.
verified_user
Strict Anti-Spam Policy
1-click unsubscribe at any time.
mark_email_unread

Subscribe to Digest

Sent weekly • No spam

person_outline
mail_outline

No spam ever. You can unsubscribe with a single click at any time.

cookie

Cookie Settings

We use cookies to enhance your browsing experience, serve personalized content, and analyze our traffic. By clicking "Accept All", you consent to our use of cookies. Learn more