E2B

Creates, connects to, pauses, and terminates ephemeral cloud sandboxes through a unified API exposed via JavaScript/TypeScript and Python SDKs. The Sandbox class manages lifecycle state transitions (create → connect → pause/kill) with automatic connection pooling and configurable timeouts. Separates sandbox lifecycle concerns from runtime operations, enabling agents to spawn isolated execution environments without managing infrastructure directly.

Provides unified file I/O operations (read, write, list, delete, mkdir) on sandbox filesystems through a Filesystem class that transparently routes operations via REST or gRPC depending on payload size and latency requirements. Implements automatic protocol selection: REST for small files (<1MB), gRPC for streaming large files. Supports file watching via watchHandle for reactive code execution patterns.

Enables sandboxes to be paused (suspending execution and freeing resources) and resumed later with filesystem and process state preserved. Implements state snapshots at pause time and restoration on resume, allowing agents to implement checkpoint-based workflows. Supports metadata persistence (custom tags, creation time) across pause/resume cycles for tracking and auditing.

Organizes E2B as a pnpm monorepo with multiple packages (JS SDK, Python SDK, CLI, docs) sharing dependencies and build configuration. Automated CI/CD pipeline builds, tests, and publishes SDKs to npm (JavaScript) and PyPI (Python) registries on each release. Shared build tooling (TypeScript, ESLint, Jest) ensures consistency across packages.

Executes arbitrary shell commands in sandboxes via a Commands class that supports both non-interactive execution (exec) and interactive pseudo-terminal sessions (PTY). Streams stdout/stderr in real-time through event emitters or async iterators, enabling agents to capture command output incrementally and react to long-running processes. Handles signal propagation (SIGTERM, SIGKILL) for process termination and exit code capture.

Defines reusable sandbox configurations as Templates that specify base OS, installed packages, environment variables, and startup commands. Templates are built from Dockerfiles or declarative YAML, cached in a registry, and referenced by name when creating sandboxes. The Template Builder API supports incremental builds with layer caching, reducing provisioning time for repeated sandbox creation. Supports both pre-built templates (Python, Node.js, etc.) and custom templates via Dockerfile.

Implements bidirectional communication between client SDKs and E2B infrastructure via gRPC (for low-latency, streaming operations) and REST (for compatibility and simplicity). The connection layer automatically selects protocols based on operation type: gRPC for file streaming and command output, REST for metadata operations. Includes automatic fallback if gRPC is unavailable (e.g., firewall restrictions), ensuring reliability across network conditions.

Exposes sandbox metadata (creation time, status, resource usage, template ID) and filtering/querying capabilities to enable agents to discover, monitor, and manage sandbox fleets. Provides metrics collection (CPU, memory, disk usage) and observability hooks for integration with monitoring systems. Supports filtering sandboxes by status, template, creation time, and custom metadata tags.

Command-line interface (@e2b/cli) for building, publishing, and managing templates, as well as creating and inspecting sandboxes without SDK code. Supports template build with caching, registry publishing, and sandbox creation from templates. Includes authentication via API key and commands for listing templates, inspecting sandbox status, and executing commands in running sandboxes.

Provides structured error types (SandboxError, FilesystemError, CommandError, etc.) with detailed diagnostic information including error codes, messages, and context. Errors include stack traces, operation details, and suggestions for remediation. Enables agents to implement sophisticated error recovery logic by catching specific exception types and inspecting error properties.

Configurable connection layer (connectionConfig) that manages SDK-to-infrastructure communication with automatic retry logic (exponential backoff), configurable timeouts per operation, and connection pooling. Supports custom retry policies, timeout overrides, and connection reuse to optimize latency and resource usage. Handles transient failures transparently without requiring agent code changes.

Provides JavaScript/TypeScript and Python SDKs with feature parity and language-idiomatic APIs (async/await in JS, asyncio in Python). Both SDKs expose the same core capabilities (sandbox lifecycle, filesystem, commands, templates) but use native language patterns (Promises vs asyncio, event emitters vs iterators). Code generation from OpenAPI schema ensures consistency across SDKs.