agent-sandbox-platform
Connects the autonomous agent loop to OpenAI model providers for live model calls, enabling real AI agent interactions within the sandbox.
Agent Sandbox Platform
Distributed via GitHub Container Registry (
ghcr.io/sumitdalavi/agent-sandbox-platform:v0.2.0) and tagged GitHub Releases with Anchore SPDX 2.3 SBOM and SHA-256 digest attestation.
The Problem
Modern distributed systems and AI agents require robust operational scaffolding. Simple CRUD apps or mock loops fail when subjected to real-world edge cases, asynchronous boundaries, and security constraints.
Related MCP server: AgentMCP
The Solution
An isolated execution platform for AI agents. An agent is given a broken service and a bounded toolset inside a disposable sandbox. Every command passes through policy, risky actions need human approval, results are verified by independent tests, and the whole run leaves a sanitized evidence bundle.
Key Capabilities & Architectural Highlights
Model Context Protocol (MCP): Server integration for Glama.ai, Smithery.ai, Claude Desktop, and Cursor.
Non-root Execution: Ephemeral container execution (UID 1000) with ReadonlyRootfs and CapDrop ALL.
5-Second Hard Deadline: Guaranteed synchronous container purge on timeout or completion.
Full OCI Distribution: Published to GitHub Container Registry (GHCR).
๐ป Tech Stack
Container Registry:
ghcr.io/sumitdalavi/agent-sandbox-platform:v0.2.0Security & Attestation: Anchore SPDX 2.3 SBOM, SHA-256 Checksums
License: MIT Open Source
๐ Documentation Index
Architecture Specification โ System diagram, component contracts, and container distribution architecture.
Production Runbook โ Operational runbook, live execution commands, and verification recipes.
Demo Walkthrough โ Step-by-step interactive demonstration scenario.
Changelog โ Full version history following Keep a Changelog and SemVer.
๐ Quickstart & Installation
Option 1: Run with Docker Container (GHCR)
docker pull ghcr.io/sumitdalavi/agent-sandbox-platform:v0.2.0
docker run -d -p 3000:3000 -v /var/run/docker.sock:/var/run/docker.sock ghcr.io/sumitdalavi/agent-sandbox-platform:v0.2.0Option 2: Run as Model Context Protocol (MCP) Server
Available on Glama.ai and Smithery.ai:
# Smithery one-line install:
npx -y @smithery/cli install SumitDalavi/agent-sandbox-platform --client claude
# Local client spec (.mcp.json):
{
"mcpServers": {
"agent-sandbox": {
"command": "node",
"args": ["mcp-server.js"]
}
}
}Option 3: Local Developer Setup
# 1. Clone the repository
git clone https://github.com/SumitDalavi/agent-sandbox-platform.git
cd agent-sandbox-platform
# 2. Build and start
make setup
make dev๐ฎ Usage & Demo
See docs/DEMO_SCRIPT.md for the interactive walkthrough and verification steps.
Demo (3 minutes)
Start "Repair failing checkout service".
Watch the agent's actual diagnostic commands stream in.
See an unauthorized network request denied by policy.
Review the proposed diff and approve export.
See independent tests pass and the sandbox torn down.
โ Verification
Operational Verification
Check | Command | Expected |
Build |
| Dependencies install successfully |
Run |
| Services start without crashing |
Test |
| Behavioral test suite passes |
Cryptographic & Supply Chain Verification
To verify the authentic origin, integrity, and software composition of release artifacts:
# 1. Download Release Bundle & Checksums
gh release download v0.2.0 --repo SumitDalavi/agent-sandbox-platform --pattern "*.tar.gz" --pattern "checksums.txt"
# 2. Verify SHA-256 Digest
sha256sum -c checksums.txt
# 3. Inspect SPDX 2.3 Software Bill of Materials
gh release download v0.2.0 --repo SumitDalavi/agent-sandbox-platform --pattern "sbom.spdx.json"
cat sbom.spdx.json | jq .spdxVersionCapability Status
Capability | Status |
Sandbox lifecycle API (create/exec/snapshot/destroy) | Implemented |
Container backend (hardened) | Implemented |
MicroVM backend (Firecracker) | Planned (stretch; requires KVM host) |
Policy engine (allowlists, limits) | Implemented |
Agent loop with real model calls | Implemented |
Human approval gate | Implemented |
Independent verification | Implemented |
Evidence bundle + timeline UI | Implemented |
Optional decision layer (risk signal) | Implemented |
Decision benchmark | Implemented |
๐ Dual-Mode Execution: Live-First with Graceful Mock Fallback
This platform operates in Dual-Mode, dynamically selecting between live container execution and self-contained policy simulation based on environment variables:
Component | Environment Variable | Live Mode Behavior | Fallback Mode (Unset / Empty) |
Container Engine |
| Launches isolated ephemeral Alpine containers via | Activates behavioral policy simulation when Docker daemon is unavailable |
Authentication Gate |
| Enforces enterprise Bearer token validation for all sandbox endpoints | Defaults to |
Policy Enforcement |
| Ingests custom organizational command blacklist (comma-separated) | Enforces default safety tokens ( |
Agent Tool Client |
| Connects live autonomous agent loop to external model providers | Runs deterministic diagnostic test scripts against sandbox APIs |
๐จโ๐ป Author
Sumit Dalavi โ Senior DevSecOps / Platform Engineer
GitHub | LinkedIn
๐ License
This project is licensed under the MIT License. Copyright (c) 2026 Sumit Dalavi.
Available Tools
2 toolsexecute_in_sandboxA
Executes untrusted shell commands or code payloads inside an isolated, non-root ephemeral Docker container with strict CPU/memory limits and timeout enforcement.
| Name | Required | Description | Default |
|---|---|---|---|
| code | Yes | The code or shell command to execute inside the sandbox | |
| timeoutMs | No | Execution deadline in milliseconds (default: 5000) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and discloses important traits: isolated, non-root, ephemeral Docker container, strict CPU/memory limits, and timeout enforcement. It stops short of covering network access, filesystem persistence, or output behavior, but the safety profile is substantially clear.
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 front-loaded sentence with no wasted words, packing the key execution context and safety constraints efficiently.
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?
There is no output schema and no annotations, so the description must carry extra weight. It explains the execution environment and limits well but omits what the tool returns (stdout, stderr, exit code) and how failures are reported, which is essential for an execution tool.
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 coverage is 100%, so both parameters are already well-documented by the input schema. The description mentions timeout enforcement, mirroring timeoutMs, but adds no extra syntax, format, or usage detail beyond the schema. Baseline 3 applies.
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 gives a specific verb and resource: executing untrusted shell commands or code payloads inside an isolated sandbox. It is clearly distinct from validate_sandbox_policy by action, but it never explicitly names or contrasts the sibling, leaving that inference to the agent.
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 phrase 'untrusted shell commands or code payloads' implies a use case, but there is no explicit guidance on when to choose this tool versus validate_sandbox_policy or when not to use it. No prerequisites, alternatives, or boundaries are stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
validate_sandbox_policyB
Evaluates a proposed command against security policy rules (e.g. denylist patterns, egress boundaries) before execution.
| Name | Required | Description | Default |
|---|---|---|---|
| command | Yes | The command to validate |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden. 'before execution' usefully signals this is a non-executing evaluation, and the examples of rule types clarify what is checked, but nothing is said about the outcome (allow/deny shape, violation details) or whether the call has side effects.
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 front-loaded sentence with no filler; the purpose and rule scope appear immediately. It is appropriately short for a one-parameter tool, though it could afford one more clause on outcomes.
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 gate-keeping tool with no annotations and no output schema, the description omits the critical piece: what the caller receives (pass/fail verdict, violation list) and how to act on a rejection. An agent cannot wire this into a pre-execution flow based on this text alone.
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 coverage is 100% for the single `command` parameter, so the baseline is 3. The description adds only light context by implying the command is evaluated against policy patterns, without clarifying format expectations (full command line vs. binary) or quoting rules.
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?
States a specific verb (Evaluates) and resource (a proposed command) plus the criteria domain (security policy rules such as denylist patterns and egress boundaries). It is clearly distinguishable from execute_in_sandbox in spirit, though the sibling is never named to make the contrast explicit.
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?
'before execution' implies this is a pre-flight check, which hints at when to call it, but the description never names execute_in_sandbox as the follow-up step, nor states what to do when validation fails. Usage is inferable rather than prescribed.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
2 tool updates
v0.1.0- First observed
execute_in_sandbox - First observed
validate_sandbox_policy
TDQS
Scored across 2 tools
The two tools have clearly distinct purposes: one performs a pre-execution policy check and the other actually runs the command in an isolated container. An agent can readily tell whether it needs validation or execution, and the descriptions reinforce the boundary.
Both names are snake_case and verb-led, giving a predictable feel. The patterns differ slightly (validate_noun vs. execute_in_noun), but they remain readable and consistent enough for reliable selection.
Two tools is thin for a platform that implies sandbox lifecycle management beyond validation and execution. The pair covers the minimal workflow, but the surface feels borderline sparse rather than well-scoped.
Core actionsโpolicy validation and isolated executionโare present, but obvious lifecycle operations such as sandbox status, cancellation, cleanup, or policy management are absent. Agents can work around some gaps because containers are ephemeral, but the surface is not fully complete for a sandbox platform.
Maintenance
Related MCP Connectors
Autonomous and governed SRE & MLOps control plane for AI agent platforms.
Build, validate, and deploy multi-agent AI solutions from any AI environment.
Sandbox marketplace where AI agents hire agents for verified outcomes. Test money only.
Security gateway for AI agents: policy, approval, and audited execution, no secrets shared.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceProvides isolated sandbox environments for AI agents to execute code securely, generating signed receipts for every execution to ensure auditability and trust.8 npm4MIT
- AlicenseNot gradedqualityDmaintenanceEnables AI agents to operate autonomously with safety, parallelism, and dynamic tool management, without giving them full machine access.1AGPL 3.0
- AlicenseNot gradedqualityDmaintenanceEnables AI agents to run compute tasks in secure sandboxes with optional interactive UIs, brokering between agents and isolated execution environments.Apache 2.0
- AlicenseNot gradedqualityCmaintenanceEnables AI agents and software engineers to investigate and resolve realistic distributed-system incidents using safe MCP-based diagnostic tools for code, logs, metrics, traces, database, and deployments.Apache 2.0