VorLoop Agent Safety

"Safety infrastructure for autonomous AI agents"

What This Is

VorLoop Agent Safety is a safety layer for autonomous AI agent platforms. We don't build agents - we make agents safe for production.

Agent Platform (OpenClaw, LangChain, MCP, CrewAI...)
                    │
                    │ "Execute this action"
                    ▼
         ┌─────────────────────────────────┐
         │   VorLoop Governance Plane      │
         │                                 │
         │  ┌───────────────────────────┐  │
         │  │ Context → Auth → Approval │  │
         │  └─────────────┬─────────────┘  │
         │                ▼                │
         │  ┌───────────────────────────┐  │
         │  │ Policy → Sandbox → Verify │  │
         │  └─────────────┬─────────────┘  │
         │                ▼                │
         │  ┌───────────────────────────┐  │
         │  │    Signed Audit Trail     │  │
         │  └───────────────────────────┘  │
         └─────────────────────────────────┘
                    │
                    ▼
         Safe, Verified, Auditable Result

Quick Start

# Install
npm install vorloop-agent-safety

# Use as library
import { safetyLayer } from 'vorloop-agent-safety';

const result = await safetyLayer.execute({
  action: 'shell',
  command: 'npm test',
  policy: 'standard',
});

# Dry-run evaluation (no execution)
const evaluation = await safetyLayer.evaluate({
  action: 'shell',
  command: 'rm -rf /tmp/test',
  policy: 'standard',
});
// Returns: { allowed, risk, requiresApproval, reasons }

See docs/QUICKSTART.md for more examples.

The Problem We Solve

Autonomous AI agents need to execute real actions: shell commands, file operations, API calls. But:

1. No guardrails - Most agent platforms have minimal safety controls
2. No audit trail - Actions can't be traced or verified after the fact
3. No verification - No way to confirm actions succeeded correctly
4. No rollback - When things go wrong, recovery is manual

VorLoop provides the missing safety infrastructure.

Core Features

1. Policy Enforcement

• Constitutional rules that cannot be bypassed
• Block dangerous commands (rm -rf /, sudo, etc.)
• Network access controls
• File path restrictions

2. Sandbox Execution

• Docker isolation with resource limits
• Network isolation
• Timeout enforcement
• Fallback to process isolation

3. Deterministic Verification

• Exit code verification
• Output pattern matching
• Security violation detection
• Custom verification rules

4. Signed Audit Trail

• Cryptographic signatures (RSA-4096)
• Hash-chained entries (blockchain-style)
• Tamper-evident logs
• External verification support

5. Dry-Run Evaluation

• Check if action would be allowed without executing
• Risk assessment (low/medium/high)
• Context-aware evaluation

6. MCP Security Proxy

• Security layer for Model Context Protocol
• Works with Claude Desktop and MCP tools
• Per-tool policy configuration
• Full audit logging

Integration Examples

OpenClaw

import { OpenClawSafetyWrapper } from 'vorloop-agent-safety/integrations/openclaw';

const wrapper = new OpenClawSafetyWrapper({ policy: 'standard' });
const result = await wrapper.execute({ type: 'shell', command: 'npm install' });

LangChain

import { createSafeTools } from 'vorloop-agent-safety/integrations/langchain';

const tools = createSafeTools({ policy: 'standard' });
// Use tools with your LangChain agent

MCP Proxy (Claude Desktop)

# Run MCP proxy with VorLoop safety
npx vorloop-mcp-proxy --policy standard

Add to claude_desktop_config.json:

{
  "mcpServers": {
    "vorloop": {
      "command": "npx",
      "args": ["vorloop-mcp-proxy", "--policy", "standard"]
    }
  }
}

REST API

# Start server
npx vorloop-agent-safety

# Execute action
curl -X POST http://localhost:3000/v1/execute \
  -H "Content-Type: application/json" \
  -d '{"action": "shell", "command": "ls -la"}'

# Dry-run evaluation
curl -X POST http://localhost:3000/v1/evaluate \
  -H "Content-Type: application/json" \
  -d '{"action": "shell", "command": "rm -rf /tmp/test"}'

Architecture

VorLoop is an agent action governance plane — like Cloudflare for AI agents.

┌─────────────────────────────────────────────────────────────────┐
│                    Agent Platform Layer                          │
│           (OpenClaw, LangChain, MCP, CrewAI, etc.)              │
└───────────────────────────┬─────────────────────────────────────┘
                            │
                            │ ActionRequest
                            ▼
┌─────────────────────────────────────────────────────────────────┐
│                  VorLoop Governance Plane                        │
│                                                                  │
│  ┌─────────────────────────────────────────────────────────────┐│
│  │ 1. Request Context   - Who/what/where/when                  ││
│  │ 2. Authorization     - May this requester ask? (stub)       ││
│  │ 3. Approval          - Is approval required? (stub)         ││
│  └────────────────────────────┬────────────────────────────────┘│
│                               ▼                                  │
│  ┌─────────────────────────────────────────────────────────────┐│
│  │ 4. Policy Engine     - Is action structurally safe?         ││
│  │ 5. Sandbox           - Docker isolation + resource limits   ││
│  │ 6. Verifier          - Exit code, output, side-effects      ││
│  └────────────────────────────┬────────────────────────────────┘│
│                               ▼                                  │
│  ┌─────────────────────────────────────────────────────────────┐│
│  │ 7. Audit Log         - Signed, hash-chained, tamper-evident ││
│  └─────────────────────────────────────────────────────────────┘│
└───────────────────────────┬─────────────────────────────────────┘
                            │
                            │ ActionResult + Signed Receipt
                            ▼
                    Safe, Verified, Audited

See docs/ARCHITECTURE.md for the full architecture.

Target Integrations

| Platform | Status | Notes | |----------|--------|-------| | OpenClaw | ✅ Tested | Wrapper implemented and tested | | LangChain | ✅ Tested | Tools implemented and tested | | MCP (Claude Desktop) | ✅ Built | Security proxy implemented | | CrewAI | 📋 Planned | | | AutoGen | 📋 Planned | |

SDKs

| Language | Status | Package | |----------|--------|---------| | JavaScript/TypeScript | ✅ Ready | vorloop-agent-safety | | Python | 🔜 Coming Soon | vorloop-agent-safety (v0.3.0) |

Roadmap

v0.2.0-alpha: Core Safety + MCP ✅ (Current)

• [x] Policy engine with constitutional rules
• [x] Sandbox execution with Docker
• [x] Deterministic verification
• [x] Signed audit logging
• [x] REST API with /v1/execute, /v1/evaluate
• [x] OpenClaw wrapper (tested)
• [x] LangChain tools (tested)
• [x] MCP Security Proxy
• [x] Request context resolver
• [x] Authorization engine (stub)
• [x] Approval engine (stub)
• [x] Dry-run evaluation (safetyLayer.evaluate())

v0.3.0: Python & Enhanced Governance (Next)

• [ ] Python SDK - Native Python support
• [ ] Full authorization engine (RBAC)
• [ ] Approval workflows with notifications
• [ ] Per-tool policy configuration
• [ ] Policy bundle versioning

v0.4.0+: Enterprise

• [ ] Multi-tenant support
• [ ] Custom policy definitions
• [ ] Compliance reporting dashboard
• [ ] Deterministic replay

Why Not Build Agents?

Building agents is crowded. Every major AI company has agent products.

Building safety infrastructure:

• No direct competitors focused on this
• Every agent platform needs it
• Plays to our strength (verification, audit)
• "Pick and shovel" during gold rush

We don't compete with agent platforms. We make them production-ready.

Status

v0.2.0-alpha - Core safety layer + MCP proxy implemented. Ready for early adopters and feedback.

npm install vorloop-agent-safety@alpha

See RELEASE_CHECKLIST.md for release details.

License

MIT