E2B MCP. Execute code safely in isolated microVMs
Gemini Works with every AI agent you already use
…and any MCP-compatible client
Just plug in your AI agents and start using Vinkius.
E2B MCP Server: Securely run Python, JavaScript, and shell code in isolated cloud sandboxes. This server lets your AI agent create, monitor, and destroy isolated Linux microVMs with a ~150ms cold start.
Use it to execute code for data science, web backends, or agent testing without risking your core infrastructure.
What your AI agents can do
Create sandbox
Starts an isolated Linux VM, letting you run code in a secure, temporary environment.
Kill sandbox
Permanently deletes a running sandbox and all its contents, freeing up system resources.
List sandboxes
Retrieves a list of all currently active sandboxes and their resource usage details.
Your agent spins up a secure, ephemeral Linux sandbox, selecting a template like Python or Node for the required runtime.
Your agent monitors all running sandboxes and tracks their templates and resource usage.
Your agent permanently deletes a sandbox and its filesystem contents, releasing allocated resources.
The sandbox supports Python, JavaScript, and general shell commands within the isolated environment.
Ask AI about this MCP
Supported MCP Clients
Gemini Waiting for input…
E2B MCP Server: 3 Tools for Sandbox Management
Use these tools to manage the complete lifecycle of isolated code execution environments, from creation to cleanup.
019d758bcreate sandbox
Starts an isolated Linux VM, letting you run code in a secure, temporary environment.
019d758bkill sandbox
Permanently deletes a running sandbox and all its contents, freeing up system resources.
019d758blist sandboxes
Retrieves a list of all currently active sandboxes and their resource usage details.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with E2B, then connect any of our 4,700+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 4,700+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
What you can do with this MCP connector
You're hooking up your AI agent to the E2B MCP Server. This thing lets your agent spin up isolated, secure Linux sandboxes, so you can run code without touching your main setup. It's built for things like data science, web backends, or just testing out an agent's logic without any risk.
Your agent can use create_sandbox to start a secure, temporary Linux VM. It'll give you a sandbox, letting your agent run code in a secure, temporary environment.
When you need to run code, it supports Python, JavaScript, and general shell commands. You can even select a specific template, like Python or Node, when you start the sandbox.
Your agent can use list_sandboxes to pull a list of all the sandboxes that are currently running. This gives you details on what templates they're using and how much resource they're eating.
When you're done with a sandbox, your agent uses kill_sandbox to permanently delete it. That action wipes the sandbox and all its contents, freeing up system resources for you.
How E2B MCP Works
- 1 Subscribe to the E2B MCP Server and provide your API key.
- 2 Your agent calls
create_sandbox, specifying the desired template (e.g., 'python3') and execution parameters. - 3 The sandbox spins up in ~150ms, allowing the agent to execute code, and the agent calls
kill_sandboxwhen finished.
The bottom line is, your agent gets a secure, temporary container to run code, and you control its entire lifecycle from start to finish.
Who Is E2B MCP For?
Any developer who builds AI agents that need to run code. This is for the engineer who can't afford to have their agent's test scripts break the production database or hang the staging environment. It’s for reliable, reproducible computation.
Build agents that need a safe place to execute generated code without risking the underlying infrastructure.
Run analysis scripts in isolated environments, ensuring the code runs the same way every time, no matter where it's executed.
Test complex multi-step agent workflows and verify generated code against production-like constraints before deployment.
What Changes When You Connect
- Isolation: The sandbox provides a dedicated Firecracker microVM with its own kernel and filesystem. Your agent can run code knowing it won't affect anything outside that container.
- Speed: Creating an isolated environment takes around 150ms. This speed lets your agent execute rapid testing cycles without long waits.
- Control: Use
list_sandboxesto track every active environment. You can monitor resource usage and see exactly what’s running. - Cleanup: The
kill_sandboxtool ensures resources are released immediately. This prevents resource leaks and keeps your costs down. - Reproducibility: Data science teams use this to run analysis scripts. Because the environment is isolated, the results are guaranteed to be reproducible.
- Language Support: The
create_sandboxtool handles Python, Node, and generic shell commands, supporting diverse agent needs.
Real-World Use Cases
Running a Data Analysis Pipeline
A data scientist needs to test a new script. Instead of running it locally, the agent uses create_sandbox with the 'python3' template. The script runs safely, and when finished, the agent calls kill_sandbox to clear the environment.
Testing Agent-Generated Backend Code
An agent writes a new API endpoint handler in JavaScript. The developer uses create_sandbox to test the code execution against mock data. This confirms the code works before pushing it to staging. The agent then calls kill_sandbox.
Debugging a Multi-Step Workflow
A complex multi-agent workflow fails. The developer uses list_sandboxes to see all active environments. They identify the failing sandbox ID and use kill_sandbox to stop the leak, then recreate a clean sandbox with create_sandbox to debug.
Validating Shell Script Outputs
An agent needs to run a complex shell command to fetch external data. The agent uses create_sandbox with a base template, executes the shell command, and confirms the output. kill_sandbox handles the cleanup.
The Tradeoffs
Relying on Local Execution
Running the agent's code on a local machine or shared server. This leads to 'it worked on my machine' issues, where dependency conflicts or system permissions break the code.
→
Use create_sandbox to get an isolated microVM. This guarantees the code runs in a clean, predictable environment, regardless of the host system's state.
Ignoring Cleanup
An agent runs a sandbox and then forgets to clean it up. This slowly leaks resources, eventually causing the entire system to run out of available memory or processes.
→
Always pair create_sandbox with kill_sandbox in your agent's logic. Use list_sandboxes to check for unexpected lingering environments.
Over-relying on Simple Logs
Trying to debug complex failures by just reading logs from a shared container. The logs might be incomplete, or the state might be corrupted by another process.
→
Use create_sandbox to provide a clean slate for the failing component. This guarantees the failure happens in a contained, auditable environment.
When It Fits, When It Doesn't
Use E2B if you need guaranteed, isolated runtime execution for code that must run in a controlled environment. This means your agent needs to run Python data scripts, validate backend functions, or execute complex shell commands without affecting the host system. Don't use E2B if you only need to send a simple message or retrieve a static piece of data. For those tasks, a simple API call is enough. If you need to run code, E2B is the right tool.
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by E2B. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Works with Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This server provides 3 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.
Available Capabilities
Code execution shouldn't require a dedicated staging server.
Today, getting your AI agent to run code means copying the code onto a staging server, spinning up a virtual machine, and dealing with dependency conflicts. You spend time configuring networking and making sure the test environment mirrors production—and it never quite does.
With the E2B MCP Server, your agent simply calls `create_sandbox`. It spins up a fully isolated microVM in 150ms. You get a guaranteed, disposable environment for running code, right from your chat or IDE.
E2B MCP Server: Manage isolated code execution
The manual steps of setting up a VM, ensuring the right dependencies are installed, and remembering to tear it down are gone. Your agent uses `create_sandbox` for setup, executes the task, and then calls `kill_sandbox` to clean up the resources automatically.
It's a full, transactional lifecycle. You get predictable resource management and guaranteed isolation every single time.
Common Questions About E2B MCP
How fast is the E2B MCP Server when running code? +
The sandbox starts in about 150ms. This fast cold start time means your agent can run rapid, iterative code tests without significant delay.
Can the E2B MCP Server run different languages? +
Yes. You can create sandboxes using templates for Python3, Node, and the base Linux environment, supporting diverse code types.
How do I stop sandboxes with the E2B MCP Server? +
You use the kill_sandbox tool. This permanently terminates the environment and releases all associated resources.
What does the E2B MCP Server list_sandboxes tool show? +
The list_sandboxes tool gives you a full inventory of all active sandboxes, showing their ID, template, status, and resource usage.
Is the E2B MCP Server secure enough for production code? +
Yes. The server runs code in isolated Firecracker microVMs. This architecture provides strong, verifiable isolation, protecting your main infrastructure.
How do I use the `create_sandbox` tool to specify a template other than the default? +
You specify the template name when calling create_sandbox. You can use predefined templates like python3 or node to start with a pre-configured environment. This ensures your code runs with the correct dependencies.
If I run code, how can I use the `list_sandboxes` tool to check for resource usage? +
The list_sandboxes tool shows all active environments, including their templates and resource status. This lets you monitor how many sandboxes are running and helps you manage your compute costs.
What happens to the data when I use the `kill_sandbox` tool? +
The kill_sandbox tool permanently deletes the sandbox and all its contents. This means the filesystem data is completely wiped, ensuring no residual data remains after termination.
How secure are E2B sandboxes? +
E2B sandboxes run as dedicated Firecracker microVMs — the same technology used by AWS Lambda and Fargate. Each sandbox has its own Linux kernel, filesystem, and network stack, providing hardware-level isolation. Code running in a sandbox cannot access your host system, other sandboxes, or any external resources unless explicitly configured.
What programming languages are supported? +
E2B supports Python, JavaScript/TypeScript, R, Java, and Bash out of the box. You can also create custom sandbox templates with any pre-installed tools, libraries, or system dependencies. The base template provides a full Ubuntu Linux environment where you can install anything via apt or pip.
How does E2B pricing work? +
E2B uses usage-based pricing billed per second of compute time. The free Hobby plan includes a one-time $100 credit (no credit card required), up to 20 concurrent sandboxes, and 1-hour maximum session length. The Pro plan starts at $150/month with 24-hour sessions and higher concurrency limits.
Multi-server workflows that include E2B MCP
Use it with your favorite AI tools
Connect this server to Cursor, Claude, VS Code, and more.
More in this category
CrewAI Platform
Orchestrate multi-agent workflows via CrewAI — list crews and agents, kickoff autonomous runs, and monitor task execution directly from any AI agent.
Google BigQuery
Empower your AI agent to query massive datasets via BigQuery — execute Standard SQL, track active jobs, and inspect table schemas natively.
OpenAI
Use GPT-4o, DALL-E 3, embeddings, fine-tuning, and moderation as tools inside your AI agent workflows.
You might also like
Percentage Calculation Engine
Stop LLMs from miscalculating discounts and interest. Deterministically calculate exact percentages and relative increases.
HealthData.gov (HHS Open Data)
Access and query thousands of U.S. health datasets from HHS — browse the catalog and perform deep data analysis via SoQL.
Civo (Cloud-native Kubernetes Cloud Provider API)
Manage Civo cloud infrastructure — provision Kubernetes clusters, control compute instances, and monitor usage directly via AI.