Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@E2B Sandbox MCP create a sandbox and open Firefox"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
🚀 AI-Powered Computer Use Through Secure Cloud Sandboxes
A powerful Model Context Protocol (MCP) server that enables AI assistants to create, control, and interact with virtual desktop environments through E2B's secure cloud sandboxes. Perfect for AI agents that need to perform computer tasks, web automation, or visual testing.
🖥️ Virtual Desktop Management: Create Ubuntu 22.04 desktop sandboxes in seconds
🎮 Complete Computer Control: Click, type, drag, scroll, and keyboard shortcuts
📺 Live VNC Streaming: Real-time desktop viewing through secure web streams
📸 Screenshot Capture: AI-ready desktop screenshots for vision processing
🔄 Lifecycle Management: Automatic cleanup and resource management
🛡️ Secure Isolation: Completely isolated environments with no host access
🔧 MCP Standard: Fully compatible with Model Context Protocol
⚡ High Performance: Optimized for AI workloads and real-time interaction
Related MCP server: MCP Toolkit
AI Agent Automation: Let AI agents perform complex computer tasks
Web Scraping & Testing: Automated browser interactions and testing
Application Testing: Visual regression testing and UI automation
Data Entry Automation: Automate form filling and data processing
Research & Analysis: AI-powered information gathering from desktop apps
Training Data Generation: Capture interaction sequences for ML training
Node.js (v18 or higher)
E2B API Key (Free tier available)
TypeScript knowledge (for development)
# Clone the repository
git clone https://github.com/your-username/e2b-sandbox-mcp.git
cd e2b-sandbox-mcp
# Install dependencies
npm install
# Build TypeScript
npm run buildCreate a .env file or set environment variables:
E2B_API_KEY=your_e2b_api_key_hereGet your E2B API key:
Visit E2B Dashboard
Sign up/log in
Navigate to "API Keys"
Create a new API key
# Start the MCP server
npm start
# Development mode with hot reload
npm run dev
# Debug mode
npm run inspectAdd to your MCP configuration file (e.g., mcp.json):
{
"mcpServers": {
"e2b-sandbox": {
"command": "node",
"args": ["/PATH_TO/e2b-sandbox-mcp/dist/index.js"],
"env": {
"OPEN_AI_API_KEY": "YOUR_OPEN_AI_API_KEY",
"E2B_API_KEY": "YOUR_E2B_API_KEY"
}
}
}
}create_sandboxCreates a new E2B desktop sandbox instance.
Parameters:
resolution (optional): Array of [width, height]. Default: [1920, 1080]
timeout (optional): Timeout in milliseconds. Default: 600000 (10 minutes)
Example:
{
"name": "create_sandbox",
"arguments": {
"resolution": [1920, 1080],
"timeout": 600000
}
}Response:
{
"sandboxId": "imy7xu1l122itq99pp4rn-9886af4b",
"streamUrl": "https://6080-sandbox-id.e2b.app/vnc.html?autoconnect=true&resize=scale",
"resolution": [1920, 1080],
"status": "created",
"message": "Sandbox created successfully"
}execute_computer_actionExecute computer actions on the sandbox desktop.
Parameters:
sandboxId: The sandbox ID to execute action on
action: Action object with type and parameters
Supported Actions:
Action Type | Description | Parameters |
| Click at coordinates |
|
| Double-click at coordinates |
|
| Type text |
|
| Press keyboard keys |
|
| Move mouse cursor |
|
| Scroll vertically |
|
| Drag from point A to B |
|
| Take screenshot | None |
Examples:
// Click example
{
"name": "execute_computer_action",
"arguments": {
"sandboxId": "sandbox-id",
"action": {
"type": "click",
"x": 100,
"y": 200,
"button": "left"
}
}
}
// Type text example
{
"name": "execute_computer_action",
"arguments": {
"sandboxId": "sandbox-id",
"action": {
"type": "type",
"text": "Hello, World!"
}
}
}
// Keyboard shortcut example
{
"name": "execute_computer_action",
"arguments": {
"sandboxId": "sandbox-id",
"action": {
"type": "keypress",
"keys": "Ctrl+c"
}
}
}
// Drag example
{
"name": "execute_computer_action",
"arguments": {
"sandboxId": "sandbox-id",
"action": {
"type": "drag",
"path": [
{"x": 100, "y": 100},
{"x": 200, "y": 200}
]
}
}
}get_stream_urlGet the VNC stream URL for viewing the desktop.
{
"name": "get_stream_url",
"arguments": {
"sandboxId": "sandbox-id"
}
}get_screenshotCapture a screenshot of the desktop.
{
"name": "get_screenshot",
"arguments": {
"sandboxId": "sandbox-id"
}
}Response:
{
"screenshot": "base64-encoded-image-data",
"format": "png",
"timestamp": "2024-01-15T10:30:00Z"
}cleanup_sandboxClean up and destroy a sandbox instance.
{
"name": "cleanup_sandbox",
"arguments": {
"sandboxId": "sandbox-id"
}
}list_sandboxesList all active sandbox instances.
{
"name": "list_sandboxes",
"arguments": {}
}import { MCPClient } from "@modelcontextprotocol/sdk/client/index.js";
class ComputerUseClient {
private mcpClient: MCPClient;
async createDesktopSession() {
// Create a new sandbox
const result = await this.mcpClient.callTool({
name: "create_sandbox",
arguments: {
resolution: [1920, 1080],
timeout: 600000,
},
});
const response = JSON.parse(result.content[0].text);
return {
sandboxId: response.sandboxId,
streamUrl: response.streamUrl,
};
}
async automateWebBrowsing(sandboxId: string, url: string) {
// Open Firefox browser
await this.mcpClient.callTool({
name: "execute_computer_action",
arguments: {
sandboxId,
action: { type: "keypress", keys: "Meta+t" },
},
});
// Type URL
await this.mcpClient.callTool({
name: "execute_computer_action",
arguments: {
sandboxId,
action: { type: "type", text: url },
},
});
// Press Enter
await this.mcpClient.callTool({
name: "execute_computer_action",
arguments: {
sandboxId,
action: { type: "keypress", keys: "Return" },
},
});
}
}import React, { useState, useEffect } from "react";
interface DesktopViewerProps {
streamUrl: string;
}
function DesktopViewer({ streamUrl }: DesktopViewerProps) {
return (
<div className="desktop-container">
<iframe
src={streamUrl}
className="w-full h-full border-0"
allow="clipboard-read; clipboard-write; fullscreen"
title="E2B Desktop Sandbox"
style={{ minHeight: "600px" }}
/>
</div>
);
}
function App() {
const [sandboxData, setSandboxData] = useState(null);
const createSandbox = async () => {
// Your MCP client call here
const response = await mcpClient.callTool({
name: "create_sandbox",
arguments: { resolution: [1920, 1080] },
});
setSandboxData(JSON.parse(response.content[0].text));
};
return (
<div className="app">
<button onClick={createSandbox} className="btn-primary">
Create Desktop Sandbox
</button>
{sandboxData && <DesktopViewer streamUrl={sandboxData.streamUrl} />}
</div>
);
}class AIComputerAgent {
constructor(private mcpClient: MCPClient) {}
async performTask(sandboxId: string, instruction: string) {
// 1. Take screenshot to understand current state
const screenshot = await this.mcpClient.callTool({
name: "get_screenshot",
arguments: { sandboxId },
});
// 2. Process with AI to determine next actions
const actions = await this.analyzeAndPlan(
instruction,
screenshot.content[0].text
);
// 3. Execute planned actions
for (const action of actions) {
await this.mcpClient.callTool({
name: "execute_computer_action",
arguments: { sandboxId, action },
});
// Small delay between actions
await new Promise((resolve) => setTimeout(resolve, 500));
}
}
private async analyzeAndPlan(instruction: string, screenshot: string) {
// Your AI logic here (OpenAI, Anthropic, etc.)
// Return array of computer actions
return [
{ type: "click", x: 100, y: 200, button: "left" },
{ type: "type", text: "Hello World" },
];
}
}┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│ AI Assistant │ │ MCP Client │ │ Your App │
│ │ │ │ │ │
│ • Claude │◄──►│ • Tool Calls │◄──►│ • Frontend │
│ • GPT-4 │ │ • Responses │ │ • Backend │
│ • Custom │ │ │ │ • API │
└─────────────────┘ └─────────────────┘ └─────────────────┘
│
▼
┌─────────────────┐
│ E2B Sandbox MCP │
│ Server │
│ │
│ • Sandbox Mgmt │
│ • Action Exec │
│ • Stream URLs │
│ • Screenshots │
└─────────────────┘
│
▼
┌─────────────────┐
│ E2B Cloud │
│ Sandboxes │
│ │
│ • Ubuntu 22.04 │
│ • VNC Streaming │
│ • Isolation │
│ • Auto Cleanup │
└─────────────────┘MCP Server: Handles tool calls and manages E2B API interactions
Sandbox Manager: Creates, tracks, and cleans up sandbox instances
Computer Use Tools: Executes mouse, keyboard, and system actions
Stream Manager: Provides VNC URLs for real-time desktop viewing
Action Executor: Translates MCP actions to E2B desktop commands
e2b-sandbox-mcp/
├── src/
│ ├── index.ts # Main MCP server entry point
│ ├── sandbox-manager.ts # E2B sandbox lifecycle management
│ └── computer-use-tools.ts # Computer action implementations
├── examples/
│ ├── simple-test.js # Basic testing script
│ ├── client-integration.ts # Advanced MCP client example
│ └── web-integration/ # Web app integration example
├── dist/ # Compiled JavaScript output
├── package.json # Dependencies and scripts
├── tsconfig.json # TypeScript configuration
└── README.md # This file# Test basic functionality
npm test
# Run web integration example
cd examples/web-integration
npm install
npm start# Start MCP server in debug mode
npm run inspect
# In another terminal, test tool calls
node examples/simple-test.js# Clone and setup
git clone https://github.com/your-username/e2b-sandbox-mcp.git
cd e2b-sandbox-mcp
# Install dependencies
npm install
# Set up environment
cp .env.example .env
# Edit .env with your E2B API key
# Start development server
npm run devnpm run build - Compile TypeScript to JavaScript
npm run dev - Start development server with hot reload
npm start - Start production server
npm run inspect - Start with Node.js debugger
npm test - Run test scripts
npm run setup - Setup and test installation
New Computer Actions: Add to src/computer-use-tools.ts
Enhanced Management: Modify src/sandbox-manager.ts
API Extensions: Update src/index.ts with new tool definitions
Problem | Solution |
| Set environment variable or pass |
| Check E2B API key validity and account quota |
| Verify sandbox is active with |
| Ensure sandbox supports VNC (desktop template) |
| Implement proper sandbox cleanup after use |
# Enable detailed logging
DEBUG=* npm run dev
# MCP-specific debugging
MCP_DEBUG=1 npm start
# Node.js inspector
npm run inspect
# Then open chrome://inspect in ChromeE2B Free Tier: 100 hours/month sandbox usage
Concurrent Sandboxes: 5 active instances (Free), more on paid plans
Timeout Limits: Default 10 minutes, configurable up to 24 hours
We welcome contributions! Please see our Contributing Guidelines.
Fork the repository
Create a feature branch: git checkout -b feature/amazing-feature
Make your changes
Add tests for new functionality
Ensure all tests pass: npm test
Commit your changes: git commit -m 'Add amazing feature'
Push to the branch: git push origin feature/amazing-feature
Open a Pull Request
Use TypeScript for all new code
Follow existing code formatting (Prettier)
Add JSDoc comments for public APIs
Include error handling and validation
This project is licensed under the MIT License - see the LICENSE file for details.
E2B for providing the cloud sandbox infrastructure
Anthropic for the Model Context Protocol specification
The open-source community for various tools and libraries used in this project
⭐ Star this repo if you find it useful!
Made with ❤️ for the AI automation community
Clean up and destroy a sandbox instance
| Name | Required | Description | Default |
|---|---|---|---|
| sandboxId | Yes | Sandbox ID to clean up |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, and the description lacks details on what 'clean up and destroy' entails (e.g., irreversible resource deletion, effect on running processes, required permissions). The agent is left uninformed about the tool's impact.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single, concise sentence that is front-loaded with the tool's action and object, containing no unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's destructive nature and lack of annotations or output schema, the description is too minimal. It does not explain side effects, return value, or usage context, leaving the agent underinformed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already describes the parameter sandboxId as 'Sandbox ID to clean up' (100% coverage). The description adds little beyond restating 'sandbox instance', so no substantial extra meaning is provided.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific actions 'clean up and destroy' with the resource 'sandbox instance', clearly distinguishing it from sibling tools like create_sandbox (creation) and list_sandboxes (listing).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives, no prerequisites mentioned (e.g., needing a valid sandboxId), and no conditions for use or cautionary notes.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Create a new E2B desktop sandbox instance
| Name | Required | Description | Default |
|---|---|---|---|
| resolution | No | Screen resolution [width, height] | |
| timeout | No | Timeout in milliseconds |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It fails to mention that creating a sandbox likely starts a new environment, consumes resources, or has limitations (e.g., concurrency). The description gives no hint about side effects, permissions, or lifecycle.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that conveys the core action without unnecessary words. It is front-loaded and clear, though it could benefit from a bit more context without losing conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has no output schema, no annotations, and 2 parameters, the description is too minimal. It does not explain what the tool returns (e.g., a sandbox ID) or any post-creation steps. Competing tools like cleanup_sandbox hint at a lifecycle that is not addressed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema covers both parameters (resolution, timeout) with descriptions. The tool description adds no extra meaning beyond the schema; for high schema coverage, the baseline is 3. The schema descriptions are concise but sufficient.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Create' and the resource 'E2B desktop sandbox instance', making the tool's purpose straightforward. It is distinct from sibling tools like cleanup_sandbox or list_sandboxes, which have different actions. However, it lacks a brief explanation of what a sandbox instance is, which could help new users.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives (e.g., list_sandboxes to check existing instances). There is no mention of prerequisites, such as needing an existing sandbox or authentication, or when it is appropriate to create a new sandbox.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Execute a computer action on the sandbox
| Name | Required | Description | Default |
|---|---|---|---|
| sandboxId | Yes | Sandbox ID to execute action on | |
| action | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description should disclose behavioral traits like side effects or safety. It only states the action is executed, without noting potential destructiveness (e.g., clicks can change state) or if the tool is idempotent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The single-sentence description is concise but overly vague. It does not front-load critical details, making it less useful for quick comprehension. Every sentence should earn its place, but this one lacks specificity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is complex with nested objects and multiple action types, but the description omits what happens after execution (return value) and behavioral nuances. No output schema is provided, so the description should compensate but fails.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema provides detailed descriptions for all parameters, including nested action properties. The description adds no extra meaning beyond the schema, meeting the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Execute a computer action on the sandbox' clearly states the verb and resource. It distinguishes from sibling tools like get_screenshot and cleanup_sandbox by implying it's a generic action executor, though not explicitly differentiating.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives like get_screenshot or cleanup_sandbox. The description does not mention prerequisites, context, or exclusions, leaving the agent without selection criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Take a screenshot of the sandbox desktop
| Name | Required | Description | Default |
|---|---|---|---|
| sandboxId | Yes | Sandbox ID to take screenshot of |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must cover behavioral traits. It correctly identifies the operation as capturing a screenshot but does not disclose whether it is read-only, requires a running sandbox, or produces any side effects. Adequate but could include details like output format or potential latency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that is extremely concise with no fluff. It front-loads the core action and resource, making it easy for an agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one parameter and no output schema, the description covers the basic function but omits important context such as what the tool returns (image data or URL?), and whether the sandbox must be active. An agent might need to infer these details.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, so the schema already defines the lone parameter. The description adds no extra meaning beyond what the schema provides, warranting the baseline score of 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action (take a screenshot) and the target resource (sandbox desktop). It distinguishes this tool from sibling tools like execute_computer_action or list_sandboxes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives, such as get_stream_url for real-time views or execute_computer_action for interactions. The description lacks context on prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get the VNC stream URL for a sandbox
| Name | Required | Description | Default |
|---|---|---|---|
| sandboxId | Yes | Sandbox ID to get stream URL for |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose any behavioral traits such as error handling, authentication requirements, or what happens if the sandboxId is invalid.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence with no unnecessary words. It is front-loaded but lacks depth.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has one parameter and no output schema, the description should provide return format or error details. It is incomplete for safe agent usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% for the sandboxId parameter, so baseline is 3. The description adds no additional meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get') and the resource ('VNC stream URL for a sandbox'). It distinguishes this tool from siblings like get_screenshot and list_sandboxes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives like get_screenshot or execute_computer_action. There is no mention of prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all active sandbox instances
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It states the tool lists active sandbox instances, which is a read operation. However, it does not disclose any other behavioral traits such as performance implications, authorization needs, or whether listings are paginated or filtered. Basic but adequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no superfluous words. It is perfectly concise and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list tool with no parameters and no output schema, the description is functional but could be improved by noting what information is returned (e.g., sandbox IDs, states). Currently it is minimal, leaving the agent to infer the return structure.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has no parameters, and the schema coverage is 100% (empty). Per guidelines, baseline is 4. The description adds no parameter meaning, but none is needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'list' and the resource 'sandbox instances', with the qualifier 'active', which distinguishes it from sibling tools like create_sandbox or cleanup_sandbox. It precisely identifies the tool's function.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for viewing active sandboxes, but provides no explicit guidance on when to use this tool versus alternatives (e.g., when to use get_screenshot or get_stream_url). No exclusions or context are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Each tool targets a distinct operation: lifecycle (create, cleanup, list), interaction (execute computer action), and observation (get screenshot, get stream URL). No overlap in functionality.
All tool names follow a consistent verb_noun pattern using snake_case (e.g., create_sandbox, get_screenshot, list_sandboxes). Only execute_computer_action has a longer form but remains consistent with the pattern.
Six tools is well-scoped for managing a remote desktop sandbox, covering creation, listing, cleanup, interaction, and screen/stream access without being excessive.
The tool set covers essential lifecycle (create, list, cleanup) and common interaction (execute action, screenshot, stream). Minor gaps like file upload or additional automation are not critical for core sandbox usage.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
A Model Context Protocol server for Wix AI tools
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to control Unreal E…
The Telnyx MCP server is an official implementation of the Model Context Protocol that enables AI clients (like Claude Desktop, Cursor, and OpenAI Agents) to interact with Telnyx's telephony, messaging, and AI assistant APIs. It provides comprehensive capabilities including making and managing phone calls, sending SMS/MMS messages, purchasing and configuring phone numbers, creating AI assistants with custom instructions, managing cloud storage buckets, scraping and embedding website content, and handling integration secrets. The server exists as both a local implementation and a remotely hosted version, allowing developers to integrate real-world communication infrastructure directly into AI applications.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/HeurisTech/e2b-sandbox-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
