---
title: "Blog | Cosmonic"
description: "Sandboxing the code AI agents run, and the systems that make it dense and fast. Engineering deep dives and security notes from the Cosmonic team."
canonical: "https://cosmonic.com/blog/"
---

![Run fleets of agent sandboxes on Kubernetes with the Cosmonic Agent SDK](https://cosmonic.com/blog/assets/images/agent-sandboxes-on-kubernetes-header-6a250f69d871daebc7a3b185e8d735c8.webp)

[Bailey Hayes](https://cosmonic.com/blog/team/bailey-hayes/)

| Nov 10, 2026| 13 min read

## [Run fleets of agent sandboxes on Kubernetes with the Cosmonic Agent SDK](https://cosmonic.com/blog/agent-sandboxes-on-kubernetes/)

### Give every agent and tool its own sandbox and run them at enterprise scale, governed by RBAC and admission policies.

An agent sandbox on Kubernetes limits what an AI agent can reach while it runs in your cluster. That's critical for security, but hardening a pod for every agent costs you scale, leaves you paying for idle infrastructure, and still has the agent and its tools sharing everything inside the pod.

With Cosmonic Control and the [open source Cosmonic Agent SDK](https://cosmonic.com/blog/cosmonic-agent-sdk/), agents and tools each run in separate, deny-by-default sandboxes that start with nothing, with many sandboxes sharing one host pod. That means you can run far more agents on far fewer nodes, and everything a sandbox can reach is declared as a line in a manifest your admission policies can check. Each sandbox is tiny, so you can run **[more than a million Codex agents on a single Kubernetes node](https://cosmonic.com/agent-sdk/)**.

In this post, we'll explain how sandboxed agents work on your cluster, why a sandbox for each component beats a pod for each special-purpose agent, and how Cosmonic Control ties your sandboxes into the Kubernetes controls you already use.

[**Read more**](https://cosmonic.com/blog/agent-sandboxes-on-kubernetes/)

![Sandbox AI agents by the million with the Cosmonic Agent SDK](https://cosmonic.com/blog/assets/images/cosmonic-agent-sdk-header-2a87c9b349ad3fd05a3a98b4e265ad13.webp)

[Bailey Hayes](https://cosmonic.com/blog/team/bailey-hayes/)

| Nov 9, 2026| 10 min read

## [Sandbox AI agents by the million with the Cosmonic Agent SDK](https://cosmonic.com/blog/cosmonic-agent-sdk/)

### The open source Cosmonic Agent SDK gives every AI agent and every tool its own sandbox, small enough to run by the million.

If you run AI agents in production, you're used to compromising between security, cost, and scale. Today we're releasing the open source [Cosmonic Agent SDK](https://cosmonic.com/agent-sdk/) so you don't have to choose.

When you build with the Agent SDK, every AI agent and tool gets its own sandbox. Each one ships as a compiled component of about a hundred KB to a handful of MB. They run side-by-side in one process, start in about a millisecond, and scale to zero. In our latest benchmark, one server held 1.75 million [Codex agents](https://cosmonic.com/docs/agents/codex-sandbox/), using about 70 KB of memory each while idle.

Agents work with OpenAI-compatible model APIs (plus Anthropic) and [MCP tools](https://cosmonic.com/mcp-security/). Your sandboxes run on any machine you control, and they're built on open standards so you aren't locked to one vendor or one cloud.

[**Read more**](https://cosmonic.com/blog/cosmonic-agent-sdk/)

![Cosmonic at KubeCon + CloudNativeCon NA 2026](https://cosmonic.com/blog/assets/images/kubecon-na-2026-header-590ac7f3138d9dafb9268b6157e20e2a.webp)

[Eric Gregory](https://cosmonic.com/blog/team/eric-gregory/)

| Nov 6, 2026| 6 min read

## [Cosmonic at KubeCon + CloudNativeCon NA 2026](https://cosmonic.com/blog/cosmonic-at-kubecon-cloudnativecon-na-2026/)

We're heading to Salt Lake City for **KubeCon + CloudNativeCon NA 2026**, and we'd love to see you there!

From November 9-12, you can find us at **Booth 224** showing sandboxed agents and tools built with the open source [Cosmonic Agent SDK](https://cosmonic.com/agent-sdk/) on [Cosmonic Desktop](https://cosmonic.com/desktop/) and [Cosmonic Control](https://cosmonic.com/control/), running a hands-on workshop on sandboxing agent tools on Kubernetes, and talking portable GPU inference at Cloud Native AI + Inference Day.

[**Read more**](https://cosmonic.com/blog/cosmonic-at-kubecon-cloudnativecon-na-2026/)

![Stop Remote Code Execution with a Sandbox: You Can't Execute What You Don't Have](https://cosmonic.com/blog/assets/images/remote-code-execution-sandbox-hero-0e725b7289a1b67f9151c8e5473b4e37.webp)

[Liam Randall](https://cosmonic.com/blog/team/liam-randall/)

| Oct 28, 2026| 28 min read

## [Stop Remote Code Execution with a Sandbox: You Can't Execute What You Don't Have](https://cosmonic.com/blog/stopping-remote-code-execution-with-a-sandbox/)

Your upload service, running as root, unzips a malicious file someone uploaded. A minute later there's a new program on your machine that runs as root, too, and you don't even know it's there. One crafted upload, and an attacker is a step away from remote code execution (RCE).

You can contain the vulnerabilities in the code you depend on with a secure, deny-by-default sandbox.

Memory-safe languages like Rust help, but they aren't enough on their own. [RUSTSEC-2026-0367](https://rustsec.org/advisories/RUSTSEC-2026-0367.html), a published flaw in the Rust `zip` crate, shipped despite the best efforts of its developers.

`zip` is one of the most widely used libraries for opening .zip files in Rust, which makes it a great case study for platform engineering teams trying to survive the #vulnpocalypse.

And it's not just open source. In many organizations, critical bugs like this one are being found so fast that CI pipelines fail constantly.

[**Read more**](https://cosmonic.com/blog/stopping-remote-code-execution-with-a-sandbox/)

![Kafka as a Capability with Cosmonic Control](https://cosmonic.com/blog/assets/images/header-be7ebfeeb725e8f784c87f1a47262f5a.webp)

[Bailey Hayes](https://cosmonic.com/blog/team/bailey-hayes/)

| Oct 7, 2026| 7 min read

## [Kafka as a Capability with Cosmonic Control](https://cosmonic.com/blog/cosmonic-kafka-native-and-in-sandbox/)

Cosmonic Control v0.12 ships native Kafka through `cosmonic:kafka@0.5.0`. Workloads can publish records, process events, use a stateful pull consumer, or commit Kafka transactions without carrying a broker address or credential in component code.

For serverless event processing, start with the `handler` interface. The host owns the Kafka consumer and keeps its group membership stable. It creates component instances when partitions have work, runs different partitions concurrently, and can reclaim every guest instance when the stream is quiet. Kafka stays connected while your compute scales independently, all the way to zero.

[**Read more**](https://cosmonic.com/blog/cosmonic-kafka-native-and-in-sandbox/)

![Cosmonic Desktop: a sandbox for your agent's code, now in public beta](https://cosmonic.com/blog/assets/images/hero-7e8cf6d19646ab6da9f2c1c3de978387.jpg)

[Liam Randall](https://cosmonic.com/blog/team/liam-randall/)

| Sep 15, 2026| 7 min read

## [Cosmonic Desktop: a sandbox for your agent's code, now in public beta](https://cosmonic.com/blog/cosmonic-desktop-public-beta/)

Your agent wrote the code. But do you trust it? Where does it run? What can it access?

For a lot of us, the answers are, "On my machine" and "Everything *I* can access." AI agents run code in our names. They carry all of our credentials and tokens, our file and network access.

And it isn't only the code they write. Every MCP server you install is third-party code wired straight into a model's tool-use loop — it takes model-shaped input, it usually holds credentials, and it can usually reach the network. You add one with a copied command, and it runs with everything you have. It's one of the toughest problems of the agentic era so far: **how do we move quickly with guardrails we can trust?**

**Cosmonic Desktop** is our answer: a free, cross-platform desktop app for running, managing, and creating sandboxed apps.

Built on open standards and designed for the agentic era, it gives your AI agents a way to run the code they generate inside a **capability-driven sandbox**, isolated from your files, your network, or your keys unless you explicitly allow it, and ready to deploy to the infrastructure you already run.

Cosmonic Desktop is free and available in **public beta** today on macOS, Linux, and Windows. It runs entirely on your machine, with no login or cloud connection required.

[**Read more**](https://cosmonic.com/blog/cosmonic-desktop-public-beta/)

![Mendy Berger talks wasi:webgpu on the WebAssembly Unleashed podcast](https://cosmonic.com/blog/assets/images/webassembly-unleashed-ep31-b08158c5f90c7d37e200952b8f8f9592.jpg)

[Eric Gregory](https://cosmonic.com/blog/team/eric-gregory/)

| Jul 24, 2026| 3 min read

## [Mendy Berger talks wasi:webgpu on the WebAssembly Unleashed podcast](https://cosmonic.com/blog/wasi-webgpu-webassembly-unleashed/)

If WebAssembly gives you portable, sandboxed access to the CPU, what's the equivalent for the GPU? That's the question at the heart of [`wasi:webgpu`](https://github.com/WebAssembly/wasi-webgpu), and the subject of the latest episode of **WebAssembly Unleashed**, where Cosmonic engineer and `wasi:webgpu` champion **Mendy Berger** joins hosts Joel Moses and Matthew Yacobucci to dig into portable GPU access for Wasm components.

[**Read more**](https://cosmonic.com/blog/wasi-webgpu-webassembly-unleashed/)

![Diving into Endive: a wasmCloud host on the JVM](https://cosmonic.com/blog/assets/images/jvm-meets-webassembly-thumbnail-compressed-0d25d43a789a5e0bb2bf8e809dfe4d53.webp)

[Eric Gregory](https://cosmonic.com/blog/team/eric-gregory/)

| May 27, 2026| 7 min read

## [Diving into Endive: a wasmCloud host on the JVM](https://cosmonic.com/blog/2026-05-26-diving-into-endive/)

The Bytecode Alliance recently [welcomed Endive](https://bytecodealliance.org/articles/endive-and-the-next-chapter-of-webassembly-on-the-jvm), a JVM-native WebAssembly runtime forked from Chicory. Endive carries Chicory's pure-Java approach forward under vendor-neutral stewardship, with a roadmap that includes the [Cranelift](https://cranelift.dev/)-based Redline compiler, WasmGC, and the [WebAssembly Component Model](https://component-model.bytecodealliance.org/).

To celebrate, we did the natural thing: we ran wasmCloud on it.

[**Read more**](https://cosmonic.com/blog/2026-05-26-diving-into-endive/)

![AI Sandbox: The Complete Guide to Sandboxing AI Agents in 2026](https://cosmonic.com/blog/assets/images/ai-sandbox-guide-header-57f562ab364e3346e015bbfbd90cc82d.webp)

[Liam Randall](https://cosmonic.com/blog/team/liam-randall/)

| May 26, 2026| 24 min read

## [AI Sandbox: The Complete Guide to Sandboxing AI Agents in 2026](https://cosmonic.com/blog/ai-sandbox-guide/)

Today, AI agents execute code, call APIs, read files, manipulate databases, and orchestrate multi-step workflows across production infrastructure. They can be tremendously accelerative tools for enterprises, but each of those actions comes with a blast radius, and the sheer speed at which they occur means that organizations need an AI sandbox to contain it.

Without proper sandboxing of AI agents, teams face an overwhelming risk surface:

- A single hallucinated tool call can exfiltrate a database.
- A prompt injection can escalate to credential theft.
- A poisoned [Model Context Protocol (MCP)](https://github.com/modelcontextprotocol/) tool can pivot from an AI agent into production systems.

This guide covers what an AI sandbox is, why AI agents need one, the four dominant approaches to isolation, and how to choose among them. In doing so, we'll explore the under-discussed questions of agent tooling and AI-generated code, where a great deal of risk resides, and the blast radius is considerable.

[**Read more**](https://cosmonic.com/blog/ai-sandbox-guide/)

![Wasmtime, AI, and the New Security Frontier](https://cosmonic.com/blog/assets/images/wasmtime-security-blog-header-75a835b143c6689936fc192a21ceabd7.webp)

[Bailey Hayes](https://cosmonic.com/blog/team/bailey-hayes/),

[Eric Gregory](https://cosmonic.com/blog/team/eric-gregory/)

| May 12, 2026| 8 min read

## [Wasmtime, AI, and the New Security Frontier](https://cosmonic.com/blog/2026-05-12-wasmtime-new-security-frontier/)

Last month the Bytecode Alliance published [security advisories for Wasmtime](https://bytecodealliance.org/articles/wasmtime-security-advisories): the largest set of advisories the project has ever published at once, triple the total number issued in all of 2025. The accompanying patch releases (Wasmtime versions 43.0.1, 42.0.2, 36.0.7, and 24.0.7) address 12 vulnerabilities surfaced with the help of a frontier AI model.

Wasmtime is one of the most rigorously engineered runtimes in open source: written in Rust, continuously fuzz-tested, backed by multiple organizations who treat it as security-critical infrastructure. What this release demonstrates is that surfacing vulnerabilities in even the most hardened codebases is no longer the hard part. Finding them quickly and at scale is now within reach of any well-resourced team with access to a capable model.

The hard part is what happens next. Teams have to review each finding, triage severity and blast radius, and patch across active versions, while coordinating disclosure with production embedders before vulnerabilities become public. That work still requires deep expertise, sustained investment, and the kind of trust that only comes from years of doing it right. It shouldn't come as a surprise that, according to [a technical blog from Anthropic Red Team](https://red.anthropic.com/2026/mythos-preview/), over 99% of vulnerabilities uncovered through similar research have not yet been patched.

At Cosmonic, we're privileged to be part of the Bytecode Alliance, and proud to be part of a community with the commitment to swift releases and advisories like the ones we saw in April.

[**Read more**](https://cosmonic.com/blog/2026-05-12-wasmtime-new-security-frontier/)
