Kimi AI and kvcache-ai Open Source ‘AgentENV’: A Distributed System Enabling Agentic Reinforcement Training (RL) in Kimi K3

Kimi’s Moonshot AI team and kvcache-ai are open source AgentENV (AENV)a distributed platform for operating agent environments at scale. AgentENV enables agentic reinforcement (RL) training for For me K32.8-trillion-Mixture-of-Experts Moonshot model. The code goes under MIT License.

Why Environment Infra Holds Agentic RL

Agentic RL is not just a sample script. It requires the model to run inside a real computer. Each release requires a separate Linux environment with a file system, network stack, and live processes.

That requirement creates a difficult trade-off. Containers start quickly but share a host kernel, which weakens the isolation of code generated by the model. Full virtual machines isolate themselves well but start up slowly and grab memory while idle.

AgentENV addresses exactly that gap. It runs Firecracker microVMs, and decommissions, reboots, and merges branches cheaply enough to run on a training scale.

Inside AgentENV’s Firecracker Architecture

Each sandbox is a Firecracker microVM with its own Linux kernel, file system, and network namespace. Requests contact the Axum HTTP API, which forwards to an orchestrator that manages the sandbox lifecycle.

Storage is where the design gets interesting. Rootfs are provided by using a blk userspace block device is supported overlaybd layered images. Read-only underlying layers are shared across sandboxes, and each sandbox writes to its own layer.

Inside each guest, a daemon called envd handles command execution, file operations, and port health reporting 49983. A reverse proxy routes HTTP and WebSocket traffic from clients to services running inside the VM.

This project also calculates two density methods. The host page cache is allocated to all storage and memory snapshot data. A memory balloon returns the guest’s recoverable memory to the host, which maintains over-commitment as environments diverge over time.

Summary, pause, restart, fork

These four factors are the reason for the existence of the project. AgentENV’s memory snapshots and file system change incrementally rather than writing a full image every time.

The reported figures are as follows. Instances supported by the snapshot start or restart under 50 ms and stand for a moment under it 100 ms. Snapping an upward snapshot finishes below 100 mseven under heavy disk deformation.

Fork is a very specific feature in RL. An active sandbox can include up to 16 independent children’s sandboxes in the same place. The source pauses during the capture, then starts again. Every child inherits the source file system, memory, and resource configuration.

The practical effect is that the expensive setup works once. The team can install dependencies, compile the repository, and access the work state. That specific situation then results in a corresponding release. Snapshots insist on storing the object on an S3-compatible or shared file system.

One default should be noted. Every sandbox has a TTL, and timeout triggers a keep quietnot delete. Deletion needs to go through autoPause: false in the create API.

On-demand loading and repositories

Images load on demand with overlaybd. A local disk acts as a buffer that stores hot data and removes cold data.

This is what makes the fleet level issue work. Nodes do not need to warm up each image or hold a complete copy of every snapshot. So a configurable image set can exceed local disk capacity while booting remains fast to converge.

The summary status is organized into three sections. The builder stage workspace holds artifacts during construction. A committed summary repository is a constant source of truth. The node-local runtime cache holds the settings obtained during startup.

Two repository backends are supported: posix_fs (default) and oss. I oss the path goes through a compatible S3 client, so it’s transparent region it is necessary.

Peer-to-peer migration supported iroh can advertise dedicated artifacts to peer nodes. Corner disabled by default. The documentation is clear that P2P does not replace the committed summary model. For shared storage, the docs ask for at least 1 Gbps and strongly recommend 10 Gbps or faster.

E2B compatibility is a lever of discovery

AgentENV exposes the E2B-compatible HTTP API. Point E2B_API_URL on your server and the official E2B Python or TypeScript SDK works without any code changes.

This is a deliberate distributional choice. Teams that already use agents in E2B can manually manage the runtime without rewriting their agent code. Native aenv A CLI is also provided, and documentation recommends AgentENV-specific workflows.

Methods of distribution

What is required is a Linux kernel 6.8+ again /dev/kvm access; the installation script also requires Ubuntu 24.04. I aenv The CLI supports Linux and macOS on x86_64 and arm64. The server itself is Linux only, because it requires KVM.

Five methods are listed:

• An installation script that runs the server as a system service
• Docker image is published in ghcr.io/kvcache-ai/aenv-server
• Docker Stack that simulates a multi-node cluster
• Kubernetes is represented by a gateway, scheduler, and DaemonSet node
• Build path from source using Rust toolchain

Multi-node deployment adds a the gate to :8080 and a editor to :9090.

Key Takeaways

• Deployments include scripting, Docker, Docker Compose, and Kubernetes; a multi-node control plane is written as a prototype.
• AgentENV uses an individual agent environment such as a Firecracker microVM, not a container, so isolation is at the kernel level.
• The project reports startup or restart in less than 50 ms, and pauses in less than 100 ms, from snapshots.
• The active sandbox can be assembled into up to 16 independent children in one place.
• The HTTP API is compatible with E2B, so existing E2B Python and TypeScript SDK code runs unchanged.

Check out the GitHub repository and documentation. All credit for this study goes to the researchers of this project.