Install Jentic One Beta

Connect the E2B API to your agent

Jentic One is a self-hosted execution layer for AI agents. It lets your agent call the E2B API, or any other public or private API you need. You set the rules, the agent never sees your credentials, and every call is logged.

Two steps, two machines. Install the instance in a safe environment, then register your agent from wherever it runs.

Step 1: Jentic One Host machine

# On the machine that will host your Jentic One instance:
curl -fsSL "https://jentic.com/install.sh?src=apis&api=%2Fapis%2Fe2b.dev%2Fe2b" | sh

Step 2: Agent machine

# On the machine where your agent runs (keep this separate from the instance):
curl -fsSL "https://jentic.com/install.sh?src=apis&api=%2Fapis%2Fe2b.dev%2Fe2b" | sh
jentic register       # connects your agent to your Jentic One instance

Jentic One is in public beta. The setup above keeps your agent separate from the instance, which is what you want before using real credentials: an agent running as the same OS user as Jentic One can read its stored keys directly. Just evaluating? A single local install is fine to start. See the secure deployment guide for the tiers.

Capabilities

What an agent can do with E2B API.

Create and list cloud sandboxes for running AI-generated code

Pause, resume, and set timeouts on a running sandbox

Stream a sandbox's logs and read its CPU and memory metrics

Build and version custom sandbox templates from files, with tags and aliases

Snapshot a sandbox and resume from the snapshot later

GET STARTED

Start building with E2B API

Explore with Jentic One

View OpenAPI Document

Use Cases

Patterns agents use E2B API for, with concrete tasks.

★ AI Agent Code Execution

Let an AI agent run code it writes in an isolated cloud sandbox instead of on the host machine: it creates a sandbox, connects to it, streams the logs while the code runs, and deletes the sandbox when the task is done. Through Jentic the agent discovers the right E2B operation by intent and calls it with the sandbox id, so a code-execution loop runs without a developer wiring the sandbox lifecycle by hand.

Create a sandbox, stream its logs while code runs, then delete the sandbox when finished

Custom Sandbox Templates

Teams bake their dependencies into a reusable sandbox image so every run starts from the same environment. The API creates a template, starts a build from the supplied files, reports build status and logs, and tags the result with a stable alias. Sandboxes then start from that template instead of installing packages on each run.

Create a template, start a build, poll the build status until it succeeds, then tag the template with a stable alias

Long-Running Sessions with Snapshots

Agents that work in several turns keep a sandbox's state between calls rather than rebuilding it each time. The API pauses a sandbox to persist its state, snapshots it, and resumes it later, while the timeout operation extends how long an idle sandbox stays alive. This keeps a session's files and processes available across an agent's steps.

Create a sandbox, pause it after setup, then resume it later and extend its timeout

Sandbox Resource Monitoring

Platform teams track how many sandboxes are running and how much they consume to control cost. The API lists sandboxes, reads each sandbox's CPU and memory metrics, and exposes team-level metrics and maximums. An agent uses these to clean up idle sandboxes before they add to the bill.

List running sandboxes, read each sandbox's CPU and memory metrics, then delete any that have been idle

Key Endpoints

53 endpoints — the e2b api creates and manages isolated cloud sandboxes where ai agents run generated code safely.

METHOD

PATH

DESCRIPTION

POST

/sandboxes

Create a sandbox

GET

/sandboxes

List sandboxes

DELETE

/sandboxes/{sandboxID}

Delete a sandbox

POST

/sandboxes/{sandboxID}/pause

Pause a sandbox

POST

/sandboxes/{sandboxID}/resume

Resume a sandbox

POST

/templates

Create a sandbox template

GET

/templates/{templateID}/builds/{buildID}/status

Get a template build status

POST

/volumes

Create a persistent volume

POST

/sandboxes

Create a sandbox

GET

/sandboxes

List sandboxes

DELETE

/sandboxes/{sandboxID}

Delete a sandbox

POST

/sandboxes/{sandboxID}/pause

Pause a sandbox

POST

/sandboxes/{sandboxID}/resume

Resume a sandbox

POST

/templates

Create a sandbox template

GET

/templates/{templateID}/builds/{buildID}/status

Get a template build status

POST

/volumes

Create a persistent volume

Why Jentic?

What agents get from Jentic-routed access to this vendor.

Setup

Wiring E2B by hand means choosing between its X-API-Key header and bearer access tokens, managing the create-pause-resume sandbox lifecycle, and polling template build status yourself. Through Jentic you install once, import E2B from the API Directory, store the API key once, and your agent calls it.

Permission scoping

E2B puts the sandbox, template, and volume ids in the URL path (/sandboxes/{sandboxID}, /templates/{templateID}), so a rule can pin your agent to specific sandboxes or templates and the operations you pick. You choose the operations it may call, so creating and reading sandboxes can be allowed while destructive ones like deleting a sandbox or killing a team's sandboxes are not included unless you add them.

Credential isolation

Your E2B API key is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.

Intent-based discovery

Agents search Jentic by intent such as 'create a code sandbox' or 'build a template', and Jentic returns the matching E2B operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

FAQs

Specific to using E2B API through Jentic.

What authentication does the E2B API use?

The E2B API authenticates with an API key in the X-API-Key header or a bearer access token per its OpenAPI spec, and some team and administrative operations use additional header tokens. Through Jentic the credential is stored encrypted by your own Jentic One instance and injected at call time, so it never enters the agent's context.

Can I run AI-generated code with the E2B API?

Yes. The create-sandbox operation starts an isolated cloud sandbox, the connect and timeout operations attach to it and keep it alive while code runs, and the logs operation streams its output. You delete the sandbox when the task is done or pause it to resume later.

What are the rate limits for the E2B API?

The OpenAPI spec does not specify rate limits; see https://e2b.dev/docs for current limits. Sandbox concurrency is governed by your team plan, which you can inspect with the team metrics operations.

Is there an E2B MCP server?

You don't need an MCP server to give your agent the E2B API. Jentic connects it directly from the API Directory: import it, store your API key once, and your agent calls operations like creating a sandbox or building a template. Operations are discovered on demand, so no extra server's tool definitions sit in your agent's context.

Can I limit what my agent is allowed to do with the E2B API?

Yes. Write a rule that allows only creating, reading, and pausing sandboxes, so the agent can run and inspect code but cannot delete sandboxes or kill a whole team's sandboxes. Because E2B addresses sandboxes and templates by id in the URL path, a rule can also pin the agent to specific sandboxes, and every call is logged.

How do I create a sandbox with the E2B API through Jentic?

Search Jentic for 'create a code execution sandbox' to find the create-sandbox operation, start the sandbox, stream its logs while code runs, then delete it. To run it on your own infrastructure, install Jentic One from its GitHub repo.

E2B API

AI ReadinessNon-Ready (F)40/100

See full scorecard

Official vendor OpenAPI document · agent-readyCloud InfrastructureComputeapiKey, bearer53 EndpointsREST

For Agents

Create and control cloud sandboxes for running AI-generated code, build custom sandbox templates, and manage snapshots, volumes, and keys. Covers 53 operations across sandboxes and templates.

Use for: Create a new sandbox to run generated code, Pause a running sandbox to save its state, Resume a paused sandbox, Stream the logs from a sandbox

Not supported: Does not handle code editing, source control, or long-term application hosting. Use for ephemeral code-execution sandboxes and their templates only.

The E2B API creates and manages isolated cloud sandboxes where AI agents run generated code safely. Agents can start a sandbox, pause and resume it, set timeouts, stream its logs, and read CPU and memory metrics, then snapshot it to resume later. Custom sandbox images are defined as templates that build from files, carry tags and aliases, and report build status and logs. The API also manages persistent volumes, team API keys, and access tokens.

Jentic One on Github View OpenAPI Document

Show dimension breakdown

Foundational Compliance

Base layer of spec validity and structural soundness.

Grade: A+Signals: 4

96%

Lint Results

Aggregated quality score from linter diagnostics, weighted by severity.

100%

Resolution Completeness

Percentage of `$ref` references that resolve successfully.

100%

Specification Validity

Checks whether the API description parses successfully and conforms to its declared specification (e.g., OpenAPI).

100%

Structural Integrity

Structural correctness score based on schema issues using logarithmic dampening.

Developer Experience & Jentic Compatibility

Clarity, completeness, and ingestion readiness for developers and tooling.

Grade: B+Signals: 4

Example Density

How richly the API is illustrated with examples.

100%

Example Validity

Percentage of examples that conform to their schemas.

74%

Response Coverage

Percentage of operations with complete response definitions (success, client error, server error).

100%

Tooling Readiness

Health of API ingestion, bundling, and resolution within Jentic pipelines.

AI-Readiness & Agent Experience

Semantic breadth, depth, and agent comprehension for AI systems.

Grade: FSignals: 4

63%

Description Coverage

Coverage of descriptions across API elements.

Error Standardization

Coverage of RFC 9457 Problem Details for error responses.

OperationId Quality

Coverage, uniqueness, and casing consistency of operationIds for AI inference.

Summary Coverage

Coverage of summaries across operations/tags/info.

Agent Usability

Functional utility, complexity comfort, and AI orchestration readiness.

Grade: A+Signals: 1

93%

Complexity Comfort

Agent comfort level based on API operational and structural complexity.

Security

Trust, risk posture, and security compliance.

Grade: C-Signals: 1

52%

Authentication Strength

Average quality of security schemes based on authentication method strength (weakest link for OAuth2).

AI Discoverability

Findability, semantic richness, and reasoning readiness.

Grade: C+Signals: 1

59%

Descriptive Richness

Clarity and depth of descriptions across API elements.

Connect the E2B API to your agent

Capabilities

Start building with E2B API

Use Cases

Key Endpoints

Why Jentic?

Related APIs

FAQs

E2B API

Jentic AI Readiness Score

E2B API

Foundational Compliance

Lint Results

Resolution Completeness

Specification Validity

Structural Integrity

Developer Experience & Jentic Compatibility

Example Density

Example Validity

Response Coverage

Tooling Readiness

AI-Readiness & Agent Experience

Description Coverage

Error Standardization

OperationId Quality

Summary Coverage

Agent Usability

Complexity Comfort

Security

Authentication Strength

AI Discoverability

Descriptive Richness