awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
kvcache-ai avatar

kvcache-ai/AgentENV

0
View on GitHub↗

AgentENV

AgentENV is a distributed sandbox platform that launches isolated Firecracker microVMs across many machines, so AI agents can run their workloads in parallel and at scale. Each environment gets its own dedicated Linux kernel, and a gateway and scheduler control plane places and manages environments across a multi-node cluster. It also serves an E2B-compatible HTTP API, so existing E2B Python and TypeScript SDK code works unchanged against your own infrastructure.

Environments are snapshot-driven. The runtime captures incremental memory and disk snapshots, pauses and resumes idle environments (restoring them within tens of milliseconds), and forks running environments into independent copies for parallel work. Snapshots can be saved to object storage or a shared filesystem. OCI-compatible images are streamed on demand through layered copy-on-write block devices, with local disk acting as a bounded cache, so images can exceed disk size. Each node runs in a single virtualization mode, either KVM or PVM, and the platform refuses to restore saved state created in the other mode.

Beyond that, the platform covers reusable sandbox templates built from snapshots, persistent named volumes mounted into sandboxes, and a reverse proxy that forwards HTTP and WebSocket traffic to services running inside them. Memory ballooning and a shared page cache let more environments fit on one host. Environments can be managed through a command-line tool, the HTTP API, or compatible SDKs.

The platform can be run from a prebuilt Docker image, installed on Ubuntu nodes with a script that sets up Firecracker and guest-kernel files for the chosen mode, or compiled from source. A source build generates an API key on first start.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI

Features

  • MicroVM Agent Sandboxes - Runs many isolated Firecracker microVM environments in parallel across machines so AI agents can execute untrusted or heavy workloads safely.
  • Distributed Workload Orchestration - Spreads sandbox workloads over a cluster, with a gateway and scheduler that place, manage, and reach environments across many nodes.
  • E2B-Compatible APIs - Serves an E2B-compatible HTTP API so existing E2B Python and TypeScript SDK code works unchanged against self-hosted infrastructure.
  • Sandbox Cluster Schedulers - Provides a gateway and scheduler control plane that places and manages sandbox environments across a multi-node cluster of machines.
  • Sandbox Forking - Captures incremental memory and filesystem snapshots, stores them in object storage or shared filesystem, and forks running environments into independent copies.
  • Snapshot Fork Restores - Pauses, resumes, snapshots, and forks running environments so parallel experiments branch from a shared starting state and idle cost stays low.
  • MicroVM Sandboxes - Runs each workload in its own Firecracker microVM with a dedicated Linux kernel so many environments run side by side without interfering.
  • MicroVM Runtime Isolations - Runs each workload in its own Firecracker microVM with a dedicated Linux kernel so many environments share a host safely.
  • Sandbox Templates - Builds reusable sandbox templates from OCI images and snapshots so teams launch new environments from a consistent baseline.
  • Centralized Control Planes - Provides a central gateway and scheduler that place and manage sandbox environments across a multi-node cluster.
  • On-Demand Layer Loading - Streams OCI image layers on demand through layered copy-on-write block devices, using local disk as a bounded cache of hot data.
  • Sandbox Pause and Resume Controls - Saves memory and disk state of idle environments to free CPU and memory, then restores them within tens of milliseconds when new work arrives.
  • Sandbox Cluster Scaling - Distributes large numbers of environments over many machines using a gateway and scheduler that place and manage sandboxes across the cluster.
  • Warm Snapshot Restores - Restores environments from saved memory and disk state within tens of milliseconds, supporting pause, resume, snapshot and fork operations.
  • Node Virtualization Modes - Runs each node in exactly one virtualization mode, KVM or PVM, provisioning only the matching Firecracker and guest kernel files.
  • Copy-on-Write Root Layering - Streams OCI image layers into stacked copy-on-write block devices so many environments share one base image with private writes.
  • Incremental Snapshotting - Captures only changed memory pages and disk blocks at each snapshot, enabling fast pause, resume, and forking of environments.
3,730 stars·364 forks·Rust·MIT·1 view

Star history

Star history chart for kvcache-ai/agentenvStar history chart for kvcache-ai/agentenv

How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

Frequently asked questions

What does kvcache-ai/agentenv do?

AgentENV is a distributed sandbox platform that launches isolated Firecracker microVMs across many machines, so AI agents can run their workloads in parallel and at scale. Each environment gets its own dedicated Linux kernel, and a gateway and scheduler control plane places and manages environments across a multi-node cluster. It also serves an E2B-compatible HTTP API, so existing E2B Python and TypeScript SDK code works unchanged against your own infrastructure.

What are the main features of kvcache-ai/agentenv?

The main features of kvcache-ai/agentenv are: MicroVM Agent Sandboxes, Distributed Workload Orchestration, E2B-Compatible APIs, Sandbox Cluster Schedulers, Sandbox Forking, Snapshot Fork Restores, MicroVM Sandboxes, MicroVM Runtime Isolations.

Which projects share features with kvcache-ai/agentenv?

Projects with overlapping indexed features include: deeplethe/sandstorm — Sandstorm is a self-hosted platform for running large numbers of isolated sandboxes for AI agents across a cluster of… superradcompany/microsandbox — Microsandbox is a runtime for creating and managing lightweight, hardware-isolated virtual machines — called sandboxes… zerocore-ai/microsandbox — microsandbox is a platform that runs untrusted code inside hardware-isolated microVMs, each with its own kernel,… agent-substrate/substrate — Substrate is a Kubernetes-based platform for running AI agents as persistent actors. Each actor keeps its memory and… e2b-dev/code-interpreter — This project is an infrastructure platform designed to provide secure, isolated, and ephemeral cloud-based Linux… mesosphere/marathon — Marathon is an Apache Mesos container orchestrator and distributed workload manager. It serves as a framework for…

Projects sharing features with AgentENV

These projects share indexed features with AgentENV. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
  • deeplethe/sandstormdeeplethe avatar

    deeplethe/sandstorm

    5,452View on GitHub↗

    Sandstorm is a self-hosted platform for running large numbers of isolated sandboxes for AI agents across a cluster of machines. A central master places sandboxes onto worker nodes, which join by pairing code or dial out from behind a NAT. Each node isolates workloads with either Firecracker microVMs or gVisor, a user-space kernel for hosts without KVM. Master, node, and web console roles ship in a single executable. What sets it apart is density and start speed. Children are forked from a warmed parent snapshot using shared copy-on-write memory, so many sandboxes start in milliseconds without

    Rustagent-infrastructureai-agentscheckpoint-restore
    View on GitHub↗5,452
  • superradcompany/microsandboxsuperradcompany avatar

    superradcompany/microsandbox

    6,570View on GitHub↗

    Microsandbox is a runtime for creating and managing lightweight, hardware-isolated virtual machines — called sandboxes — that boot directly from standard OCI container images. Each sandbox runs as its own host process with a separate kernel, filesystem, and network stack, providing process-per-sandbox isolation. The project includes a command-line tool and multi-language SDKs (Rust, TypeScript, Python, Go) for programmatic lifecycle control, and it communicates with sandbox agents over Unix sockets using a CBOR-encoded protocol. What distinguishes Microsandbox is its combination of host-manag

    Rust
    View on GitHub↗6,570
  • zerocore-ai/microsandboxzerocore-ai avatar

    zerocore-ai/microsandbox

    4,802View on GitHub↗

    microsandbox is a platform that runs untrusted code inside hardware-isolated microVMs, each with its own kernel, filesystem, and network stack. It boots directly from standard OCI container images, supports copy-on-write filesystem layers, and integrates with AI agents to execute tool calls and generated code in isolated environments with secret protection. What sets microsandbox apart is its host-side network proxy that enforces firewall rules, intercepts DNS, inspects TLS traffic, and injects secrets at the network boundary without exposing them inside the VM. It provides SSH access to micr

    Rustagentsaiai-generated
    View on GitHub↗4,802
  • agent-substrate/substrateagent-substrate avatar

    agent-substrate/substrate

    6,195View on GitHub↗

    Substrate is a Kubernetes-based platform for running AI agents as persistent actors. Each actor keeps its memory and filesystem state across idle periods: when it goes quiet, it is snapshotted to durable object storage and its worker is freed, and it is later restored onto any available worker when a request arrives. Agents built on any framework can run from standard container images without code changes, and each untrusted agent runs in its own gVisor or microVM sandbox with separate compute, network, and storage. What sets it apart is the combination of density and containment. Because mos

    Goagentscncfsandboxing
    View on GitHub↗6,195
  • Compare all 30 related projects→