Get In Touch

Give AI agents a sandbox.
On your own Kubernetes.

AI coding agents generate code you didn't write and run it against systems you can't afford to lose. mogenius gives every agent an AI agent sandbox: an ephemeral, isolated environment to execute and validate that code, provisioned on demand, governed by RBAC and audit, and running on your cluster. Your source and secrets never leave your infrastructure.

🤖
AI Agent
local, in CI, or in-sandbox
MCP · API · CLI
Sandbox · your cluster
⚙
Ephemeral workload
scoped namespace · runs the generated code
NetworkPolicy RBAC Audited Egress-controlled
Nothing leaves your infrastructure
Every action attributed

Agents running code on a laptop
is a blast radius you can't audit.

Agent code on the developer machine
Generated code runs next to SSH keys, env files, cloud credentials, and the corporate VPN: the blast radius is the whole machine
No egress control: the code can read your source and send it anywhere
No attribution and no trail: nobody can reconstruct what an agent touched, or prove it to an auditor
The alternative, a third-party cloud sandbox, ships your code to US infrastructure and caps you with session limits
It's a separate silo, not a layer in the platform your team already runs
With mogenius Agent Sandbox
Code executes in an isolated, ephemeral workload: a scoped namespace with no access to developer machines or company secrets
Egress is governed by network policy; the sandbox only reaches what you allow
Every create, exec, and egress attempt is attributed to a developer or agent and logged
Runs on your own Kubernetes: any cloud, on-prem, air-gapped. No data leaves your infrastructure
A native capability of your mogenius platform: same operator, RBAC, workspaces, and audit

Provisioned on demand.
Torn down when it's done.

Kubernetes-native sandboxes, consumed at PaaS level.

An agent requests a sandbox through the mogenius interface it already speaks: MCP, API, CLI, or UI. The operator materializes the Kubernetes resources, the mogenius API hands back access, and the UI lets you watch and troubleshoot the running sandbox like any other workload. When the work is finished, the sandbox is suspended or destroyed.

  • Built on the Kubernetes SIG agent-sandbox project: no proprietary runtime, no lock-in
  • Isolation by default: dedicated namespace plus network policy
  • Optional kernel-level isolation (gVisor / Kata) for untrusted code
  • Suspend & resume, or destroy: ephemeral by design, no session limits
  • Reuses the governance you already have: RBAC, workspaces, audit
AGENT Local, in CI, or running in-sandbox
↓ MCP · API · CLI · UI ↓
MOGENIUS RBAC → Workspace → Audit Log
↓ Operator reconciles ↓
SANDBOX Scoped namespace → isolated pod
The agent never touches your real workloads or the host machine. Every request is mediated, governed, and logged.

Keep the agent outside,
or put it inside.

Mode A

Agent outside, code inside

Your agent runs where it runs today, a developer's IDE, a CI job, and requests a sandbox through the mogenius MCP server. The generated code executes and is validated inside the sandbox on your cluster, never on the machine that launched it.

  • The laptop stays clean: no generated code touches it
  • One MCP tool call to create, exec, and tear down
  • Ideal for IDE agents and PR-validation pipelines
Mode B

The whole agent in the sandbox

Run the entire agent inside the sandbox, for example an OpenCode-style CLI, with your model connected over an endpoint you choose, including a self-hosted one. The agent lives and dies with the sandbox and never has standing access to anything else.

  • Fully contained autonomous runs, start to finish
  • Bring your own model endpoint: external or self-hosted
  • Nothing persists beyond the sandbox's lifetime

One capability.
MCP, API, CLI, UI.

Sandboxes are first-class, not a bolt-on.

Request a sandbox from an AI agent over MCP, script it through the API, drive it from the CLI, or monitor it in the UI. Every path resolves to the same custom resources, the same RBAC check, and the same audit entry, so an agent can't do anything a developer couldn't, and nothing goes unrecorded.

  • MCP: agents request sandboxes in the same governed server they already use for K8s operations
  • API: wire sandboxes into pipelines and internal tools
  • CLI: create, exec, and tear down from your terminal
  • UI: watch, inspect, and troubleshoot running sandboxes
# agent requests a sandbox via MCP, then runs its code
agent → create-sandbox --workspace team-checkout
Identity: dev/sarah.k via claude-code · RBAC ✓
Namespace: sbx-9f3a · NetworkPolicy applied · egress: deny-all
✓ sandbox sbx-9f3a ready
agent → exec-in-sandbox sbx-9f3a -- npm test
Logged: sandbox/exec · attributed: sarah.k
✓ tests passed · 18.2s
agent → suspend-sandbox sbx-9f3a
✓ suspended · destroyed on TTL
Your K8s

Any cloud, on-prem, or air-gapped: nothing leaves your infrastructure

No limit

No session caps: sandboxes live as long as the work needs

100%

Sandbox actions attributed and logged for audit

Open

Built on the Kubernetes SIG agent-sandbox project: no lock-in

Untrusted code runs.
Your data stays home.

A sandbox exists to run code you haven't reviewed. mogenius treats that as a security boundary, not a convenience. Each sandbox is isolated at the namespace level with network policy, egress is denied by default, and sensitive runs can be pinned to a hardened runtime. The whole thing lives on infrastructure you control.

Because sandboxes reuse the mogenius control plane, the same RBAC and audit that govern your clusters govern them too. Every action is attributed to a real identity and reconstructible: the evidence an ISO 27001 or BSI audit asks for is simply the log.

🔒

Isolated & egress-controlled

Dedicated namespace and network policy per sandbox, egress denied by default. Optional gVisor / Kata runtime for untrusted workloads.

📝

Attributed & auditable

Create, exec, and egress attempts are logged against a developer or agent identity, ready for compliance and incident reconstruction.

🌎

Sovereign by default

Runs on your own Kubernetes, in your region or on-prem. GDPR-ready, air-gapped capable, no third-party runtime in the path.

Frequently asked questions

What is an AI agent sandbox?

An AI agent sandbox is an isolated, short-lived environment where an AI agent executes the code it generates, without access to production systems, developer machines, or company secrets. mogenius Agent Sandbox provides these environments on your own Kubernetes cluster: a dedicated namespace and network policy per sandbox with egress denied by default, provisioned on demand and suspended or destroyed when the work ends, every create, exec, and egress attempt logged against a developer or agent identity, and built on the open-source Kubernetes SIG agent-sandbox project.

How can companies run AI coding agents like Claude Code securely?

Move the execution of agent-generated code off developer laptops and into governed sandboxes on your own infrastructure. On a laptop, that code runs next to SSH keys, env files, cloud credentials, and the corporate VPN, with no isolation, no egress control, and no attribution if something goes wrong. With mogenius Agent Sandbox, an agent requests a sandbox through the mogenius MCP server, API, CLI, or UI: generated code executes in an isolated, egress-controlled namespace while the agent stays in the IDE, or the whole agent runs inside the sandbox with no standing access to anything else. Every action reuses the RBAC, workspaces, and audit log that already govern the rest of the platform. More on governing agents: AI Agent Governance.

How do I keep an AI coding agent session running after I close my laptop?

Run the session on a server or Kubernetes cluster instead of your local machine, so it keeps going when your laptop sleeps or disconnects. A local session ends with the laptop: a task started in the afternoon is lost the moment you leave for the day. With mogenius Agent Sandbox, a platform team turns an existing cluster into an always-on sandbox environment for the whole team: sessions run around the clock with no session caps, connect to an external or self-hosted model endpoint, and every action is logged and attributed, so the results are waiting the next morning.

How do I isolate AI agent sessions in my own AI product?

Give every user or agent session its own ephemeral sandbox, created on demand through the API or MCP and destroyed when the session ends, so sessions cannot see each other's data and generated code only reaches what you allow. mogenius Agent Sandbox provides this on your own Kubernetes: generated code runs and is validated inside the sandbox, egress is denied by default, untrusted workloads can be pinned to a hardened gVisor or Kata runtime, and every session's actions are attributed and logged for audit.

Is there a GDPR-compliant sandbox for AI agents?

Yes. A sandbox that runs on your own Kubernetes, in your own region or on premises, keeps agent code and data under your control, unlike many third-party cloud sandboxes that process code on US infrastructure and cap session length. mogenius Agent Sandbox runs on any cloud, on-premises, or air-gapped cluster, with no third-party runtime in the path and no session caps. Attributed, logged sandbox actions provide the evidence an ISO 27001 or BSI audit asks for, built on the open Kubernetes SIG agent-sandbox project with no proprietary lock-in. More: mogenius on customer cloud and on-prem.

What is the Kubernetes Agent Sandbox project?

An open-source Kubernetes SIG initiative that defines custom resources for running AI agent workloads in short-lived, isolated sandboxes on a cluster. It standardizes how a sandbox is created, executed in, and torn down, so platforms like mogenius Agent Sandbox can build on it instead of a proprietary runtime. The project lives on GitHub at kubernetes-sigs/agent-sandbox.

Let agents run code.
On your terms.

Ephemeral, governed sandboxes for AI agents, on your own Kubernetes, with nothing leaving your infrastructure.

Book a Demo See Full Platform

Certifications & Memberships

mogenius is a CNCF Silver Member, a NeoNephos Foundation member, a Certified Kubernetes product, and ISO 27001 certified via TÜV Saarland.