PRODUCTION AI AGENT INFRASTRUCTURE ANALYSIS

kagent 1.0 Makes Agent State a Schedulable Runtime Boundary

Solo.io has released kagent 1.0 and Agent Substrate for production AI agents on Kubernetes. Durable state, per-actor identity, isolation, and gateway policy must move together when an agent resumes.

6 min read

What Solo.io released

On November 10, Solo.io announced general availability of kagent 1.0 and enterprise releases of kagent and Agent Substrate. Agent Substrate runs agent-style workloads as actors on pools of warm Kubernetes worker Pods. It can suspend an idle actor, persist its workspace and optionally memory, then restore it on an eligible worker when a request arrives. Solo.io says every actor runs in a gVisor or microVM sandbox and receives a SPIFFE-based identity that follows it between workers.

kagent is the higher-level layer for users, conversations, agents, and sandboxes. The announcement lists declarative agent definitions, version-pinned conversations, auto-suspend, human approval waits, checkpoints and forks, OIDC-based ownership, gateway-injected credentials, A2A and MCP access, and OpenTelemetry telemetry. Solo.io also reports production use by OutSystems and Swissquote. These are the company’s product and customer claims; the engineering conclusions below are Ineeza analysis.

The unit of operation is the actor, not the Pod

A conventional service replica is expected to be replaceable and mostly stateless. An agent session instead accumulates a workspace, waits for models or people, executes generated code, and acts for a particular user. Solo.io’s architecture separates that logical actor from the warm worker that supplies compute.

Ineeza analysis: production systems must make the actor the unit for lifecycle, ownership, policy, cost, and incident response. A Pod restart metric is insufficient when the same actor can resume elsewhere. Operators need an immutable actor identifier, a state-generation number, the active policy and agent-definition versions, and a trace linking every suspend, snapshot, placement, restore, and termination decision.

Resume is a security-sensitive state transition

Restoring a workspace is not equivalent to restarting a stateless process. The actor may contain code, tool output, partial plans, uncommitted files, and an outstanding human approval. Meanwhile, policies, models, tool schemas, or vulnerabilities may have changed while it was suspended.

Ineeza analysis: every resume should validate snapshot integrity, actor ownership, policy compatibility, tool and model availability, revocation state, and the exact continuation point before execution. A snapshot created under an obsolete policy must not silently inherit broader current access. Define quarantine and migration paths for incompatible state, and make approval tokens single-use, operation-bound, and invalid after material plan or environment changes.

Identity and credentials must follow different paths

Solo.io says actor identity follows the actor across workers, while outbound credentials remain outside the sandbox and are injected by an egress gateway after policy evaluation. That separation reduces the value of secrets exposed through generated code or prompt injection.

Ineeza analysis: treat actor identity as evidence of which workload is requesting an action, not as permission by itself. Authorization should join actor, initiating user, tenant, conversation, approved purpose, tool, destination, and request parameters. Credential injection must occur only after that decision and must be observable without recording the credential. Tests should prove that restored or forked actors cannot reuse stale grants, cross tenant boundaries, or reach undeclared destinations.

Capacity moves from idle Pods to wake-up guarantees

Suspend and resume can release compute while conversations wait, and warm workers can avoid a full Kubernetes scheduling path for every turn or tool call. This changes the dominant operational question from how many always-on Pods exist to whether the platform can restore the right actor fast enough under burst load.

Ineeza analysis: define service objectives for queue time, restore latency, snapshot durability, placement failure, and state loss—not only CPU utilization. Capacity tests should include correlated wake-ups, large workspaces, worker loss during snapshot or restore, unavailable storage, and policy-gateway degradation. Backpressure must preserve fairness between tenants and must never cause a client retry to create a second active copy of one actor.

Versioned conversations need an explicit upgrade contract

The announcement says new conversations can adopt a changed prompt or model while in-flight conversations retain the version they started with. It also says migration from kagent 0.x to 1.0 requires a fresh install. Both points expose versioning as an operational boundary rather than a deployment detail.

Ineeza analysis: record the agent definition, model, prompt, tool schemas, sandbox image, policy bundle, and state format for every conversation. Define which combinations can resume, fork, export, or be retired. A rollout is safe only when rollback covers both control-plane code and persisted actor state; otherwise an application rollback can strand sessions created by a newer schema.

Ineeza’s view

kagent 1.0 is materially important because it treats waiting, stateful AI agents as a workload class that does not fit a Pod-per-session model. The useful production abstraction is not simply a faster sandbox. It is a schedulable actor whose state, identity, policy, evidence, and authority remain coherent as compute is released and reacquired. Teams evaluating this architecture should prove that coherence through suspend, restore, fork, revocation, failure, and upgrade scenarios before allowing agents to operate consequential systems.

← Ineeza home