Skip to main content
Glama
SumitDalavi

agent-sandbox-platform

Agent Sandbox Platform

CI Pipeline Release Release Workflow SBOM License: MIT

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.0

  • Security & 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.0

Option 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)

  1. Start "Repair failing checkout service".

  2. Watch the agent's actual diagnostic commands stream in.

  3. See an unauthorized network request denied by policy.

  4. Review the proposed diff and approve export.

  5. See independent tests pass and the sandbox torn down.


โœ… Verification

Operational Verification

Check

Command

Expected

Build

make setup

Dependencies install successfully

Run

make dev

Services start without crashing

Test

make 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 .spdxVersion

Capability 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

DOCKER_HOST / default socket

Launches isolated ephemeral Alpine containers via /var/run/docker.sock

Activates behavioral policy simulation when Docker daemon is unavailable

Authentication Gate

API_TOKEN

Enforces enterprise Bearer token validation for all sandbox endpoints

Defaults to valid-token for local development

Policy Enforcement

POLICY_BLOCKED_TOKENS

Ingests custom organizational command blacklist (comma-separated)

Enforces default safety tokens (rm, curl, wget, nc, bash)

Agent Tool Client

OPENAI_API_KEY / GEMINI_API_KEY

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 tools
execute_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.

ParametersJSON Schema
NameRequiredDescriptionDefault
codeYesThe code or shell command to execute inside the sandbox
timeoutMsNoExecution deadline in milliseconds (default: 5000)

TDQS

A3.5/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness3/5

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.

Parameters3/5

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.

Purpose4/5

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.

Usage Guidelines2/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
commandYesThe command to validate

TDQS

B3.3/5.0
Behavior3/5

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.

Conciseness4/5

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.

Completeness2/5

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.

Parameters3/5

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.

Purpose4/5

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.

Usage Guidelines3/5

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.

  1. 2 tool updatesv0.1.0
    • First observedexecute_in_sandbox
    • First observedvalidate_sandbox_policy

TDQS

A3.5/5.0

Scored across 2 tools

Disambiguation5/5

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.

Naming Consistency4/5

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.

Tool Count3/5

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.

Completeness3/5

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

ActivityMaintained
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers