Vibe Engine Documentation

Quickstart

Get up and running with Vibe Engine in under 5 minutes. Choose your preferred language:

# Install the SDK
pip install vibengine

# Create and run a sandbox
from vibengine import VibeEngine

client = VibeEngine(api_key="your-api-key")

# Launch a Python sandbox
sandbox = client.sandbox.create(
    template="python-3.12",
    region="us-east-1"
)

# Execute code
result = sandbox.execute("print('Hello from Vibe Engine!')")
print(result.stdout)  # Hello from Vibe Engine!

# Clean up
sandbox.terminate()

// Install the SDK
// npm install @vibengine/sdk

import { VibeEngine } from '@vibengine/sdk';

const client = new VibeEngine({ apiKey: 'your-api-key' });

// Launch a Node.js sandbox
const sandbox = await client.sandbox.create({
  template: 'node-20',
  region: 'us-east-1'
});

// Execute code
const result = await sandbox.execute(`console.log('Hello from Vibe Engine!')`);
console.log(result.stdout); // Hello from Vibe Engine!

// Clean up
await sandbox.terminate();

# Create a sandbox
curl -X POST https://api.vibengine.cloud/v1/sandboxes \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "template": "python-3.12",
    "region": "us-east-1"
  }'

# Execute code in sandbox
curl -X POST https://api.vibengine.cloud/v1/sandboxes/{sandbox_id}/execute \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"code": "print(\"Hello from Vibe Engine!\")"}'

Core Concepts

Sandboxes

A sandbox is an isolated computing environment powered by a Firecracker microVM. Each sandbox has its own kernel, filesystem, and network stack — providing hardware-level isolation that's fundamentally stronger than containers.

Templates

Templates are pre-built sandbox images optimized for specific runtimes. Each template includes the language runtime, common packages, and Vibe Engine's execution agent.

Lifecycle

Sandboxes follow a simple lifecycle:

creating ──> running ──> executing ──> idle ──> terminated
                │                        │
                └── paused ──────────────┘

Authentication

All API requests require authentication via an API key passed in the Authorization header.

Authorization: Bearer vibe_sk_xxxxxxxxxxxxxxxxxxxxxxxx

API keys can be created and managed from the Vibe Engine Dashboard. Each key is scoped to an organization and can have fine-grained permissions:

Python SDK

The official Python SDK provides a Pythonic interface to the Vibe Engine API with full type hints and async support.

Installation

pip install vibengine

Basic Usage

from vibengine import VibeEngine

client = VibeEngine(api_key="vibe_sk_...")

# Create a sandbox with custom configuration
sandbox = client.sandbox.create(
    template="python-3.12",
    memory_mb=1024,
    vcpu=2,
    timeout=7200,
    region="us-east-1",
    env={
        "DATABASE_URL": "postgresql://...",
        "API_KEY": "secret"
    }
)

# Execute code and get results
result = sandbox.execute("""
import numpy as np
data = np.random.randn(1000)
print(f"Mean: {data.mean():.4f}")
print(f"Std:  {data.std():.4f}")
""")

print(result.stdout)
print(f"Exit code: {result.exit_code}")
print(f"Duration: {result.duration_ms}ms")

Async Support

import asyncio
from vibengine import AsyncVibeEngine

async def main():
    client = AsyncVibeEngine(api_key="vibe_sk_...")

    # Launch multiple sandboxes concurrently
    sandboxes = await asyncio.gather(*[
        client.sandbox.create(template="python-3.12")
        for _ in range(10)
    ])

    # Execute in parallel
    results = await asyncio.gather(*[
        sb.execute("print('parallel execution!')")
        for sb in sandboxes
    ])

asyncio.run(main())

File Operations

# Upload a file to the sandbox
sandbox.filesystem.upload("/app/data.csv", local_path="./data.csv")

# Write content directly
sandbox.filesystem.write("/app/config.json", '{"debug": true}')

# Read a file
content = sandbox.filesystem.read("/app/output.txt")

# List directory contents
files = sandbox.filesystem.list("/app")
for f in files:
    print(f"{f.name} ({f.size} bytes)")

JavaScript SDK

The JavaScript/TypeScript SDK works in both Node.js and edge runtimes with full TypeScript support.

Installation

npm install @vibengine/sdk

Basic Usage

import { VibeEngine } from '@vibengine/sdk';

const client = new VibeEngine({ apiKey: 'vibe_sk_...' });

// Create a sandbox
const sandbox = await client.sandbox.create({
  template: 'node-20',
  memoryMb: 1024,
  timeout: 3600,
});

// Execute with streaming output
const stream = sandbox.executeStream(`
  for (let i = 0; i < 10; i++) {
    console.log(\`Processing step \${i + 1}/10...\`);
    await new Promise(r => setTimeout(r, 100));
  }
  console.log('Done!');
`);

for await (const chunk of stream) {
  process.stdout.write(chunk.data);
}

await sandbox.terminate();

TypeScript Types

import type {
  Sandbox,
  SandboxConfig,
  ExecutionResult,
  FileInfo,
  StreamChunk,
} from '@vibengine/sdk';

const config: SandboxConfig = {
  template: 'python-3.12',
  memoryMb: 2048,
  vcpu: 4,
  region: 'eu-west-1',
  persistentStorage: true,
};

SDK Configuration

Both SDKs support extensive configuration options:

# Python — environment variable configuration
# export VIBENGINE_API_KEY=vibe_sk_...
# export VIBENGINE_BASE_URL=https://api.vibengine.cloud

from vibengine import VibeEngine

# Auto-detects from environment
client = VibeEngine()

REST API Reference

The Vibe Engine REST API uses standard HTTP methods and returns JSON responses. Base URL: https://api.vibengine.cloud/v1

Response Format

{
  "status": "success",
  "data": { ... },
  "request_id": "req_abc123"
}

Error Format

{
  "status": "error",
  "error": {
    "code": "sandbox_not_found",
    "message": "Sandbox with ID 'sbx_123' was not found"
  },
  "request_id": "req_abc123"
}

Rate Limits

API: Sandboxes

POST /v1/sandboxes

Create a new sandbox instance.

curl -X POST https://api.vibengine.cloud/v1/sandboxes \
  -H "Authorization: Bearer vibe_sk_..." \
  -H "Content-Type: application/json" \
  -d '{
    "template": "python-3.12",
    "region": "us-east-1",
    "memory_mb": 1024,
    "vcpu": 2,
    "timeout": 3600,
    "env": {"KEY": "value"},
    "metadata": {"project": "my-app"}
  }'

# Response
{
  "status": "success",
  "data": {
    "id": "sbx_7f3k2m9x",
    "template": "python-3.12",
    "region": "us-east-1",
    "state": "running",
    "memory_mb": 1024,
    "vcpu": 2,
    "created_at": "2026-05-21T12:00:00Z",
    "expires_at": "2026-05-21T13:00:00Z"
  }
}

GET /v1/sandboxes

List all active sandboxes for the current organization.

curl https://api.vibengine.cloud/v1/sandboxes \
  -H "Authorization: Bearer vibe_sk_..."

# Query parameters: state, template, region, limit, cursor

GET /v1/sandboxes/:id

Get details of a specific sandbox.

DELETE /v1/sandboxes/:id

Terminate a sandbox immediately.

API: Filesystems

POST /v1/sandboxes/:id/files

Upload or write a file to the sandbox filesystem.

curl -X POST https://api.vibengine.cloud/v1/sandboxes/sbx_7f3k2m9x/files \
  -H "Authorization: Bearer vibe_sk_..." \
  -F "path=/app/script.py" \
  -F "content=@local_script.py"

GET /v1/sandboxes/:id/files?path=/app/output.txt

Read file contents from the sandbox.

GET /v1/sandboxes/:id/files?path=/app&list=true

List directory contents.

API: Code Execution

POST /v1/sandboxes/:id/execute

Execute code inside a running sandbox.

curl -X POST https://api.vibengine.cloud/v1/sandboxes/sbx_7f3k2m9x/execute \
  -H "Authorization: Bearer vibe_sk_..." \
  -H "Content-Type: application/json" \
  -d '{
    "code": "import sys; print(sys.version)",
    "timeout": 30,
    "stream": false
  }'

# Response
{
  "status": "success",
  "data": {
    "stdout": "3.12.4 (main, Jun 2026) [GCC 12.2.0]\n",
    "stderr": "",
    "exit_code": 0,
    "duration_ms": 42
  }
}

Execution Options

API: WebSocket Streaming

For real-time output streaming, connect via WebSocket:

wss://api.vibengine.cloud/v1/sandboxes/{sandbox_id}/ws

// Send execution request
{
  "type": "execute",
  "code": "for i in range(10): print(f'Step {i}')",
  "stream": true
}

// Receive streaming output
{"type": "stdout", "data": "Step 0\n", "timestamp": 1716300000}
{"type": "stdout", "data": "Step 1\n", "timestamp": 1716300001}
...
{"type": "exit", "exit_code": 0, "duration_ms": 1042}

Guide: AI Agent Sandboxes

Vibe Engine is purpose-built for AI agent code execution. Give your agents a secure, isolated environment to run arbitrary code without risking your infrastructure.

Why Vibe Engine for AI Agents?

• Safe execution — Each agent runs in its own microVM with hardware isolation. A malicious or buggy script cannot escape the sandbox.
• Fast iteration — Sub-500ms launch means agents can spin up fresh environments for every task.
• Full capability — Network access, package installation, file I/O — agents have real computing power, not a hobbled REPL.
• Scalable — Run 10,000+ concurrent agent sessions across global regions.

Example: LLM Code Interpreter

from vibengine import VibeEngine

client = VibeEngine()

def run_agent_code(code: str, context: dict) -> dict:
    """Execute LLM-generated code in an isolated sandbox."""
    sandbox = client.sandbox.create(
        template="python-3.12",
        memory_mb=2048,
        timeout=300,
        env=context.get("env", {})
    )

    try:
        # Upload any context files
        for name, content in context.get("files", {}).items():
            sandbox.filesystem.write(f"/app/{name}", content)

        # Execute agent code
        result = sandbox.execute(code)

        return {
            "output": result.stdout,
            "errors": result.stderr,
            "exit_code": result.exit_code,
            "files": sandbox.filesystem.list("/app")
        }
    finally:
        sandbox.terminate()

Guide: CI/CD Pipeline Isolation

Run each CI job in a dedicated microVM for perfect isolation between builds.

# .vibengine/pipeline.yml
stages:
  - name: test
    template: node-20
    memory_mb: 2048
    commands:
      - npm ci
      - npm run lint
      - npm test

  - name: build
    template: node-20
    memory_mb: 4096
    commands:
      - npm ci
      - npm run build
    artifacts:
      - dist/**

  - name: security
    template: python-3.12
    commands:
      - pip install safety bandit
      - safety check
      - bandit -r src/

Guide: Enterprise Setup

Vibe Engine Enterprise includes dedicated infrastructure, compliance features, and premium support.

Enterprise Features

Guide: Networking & Isolation

Each sandbox runs in an isolated network namespace. By default, sandboxes have outbound internet access but are not reachable from the outside.

Network Modes

Architecture

Vibe Engine is built on a microservices architecture with Firecracker microVMs at its core.

┌─────────────────────────────────────────────────────┐
│                   Client Layer                       │
│  Python SDK  │  JS SDK  │  REST API  │  WebSocket   │
└──────────────────────┬──────────────────────────────┘
                       │ HTTPS / WSS
┌──────────────────────▼──────────────────────────────┐
│                  API Gateway                         │
│  Auth  │  Rate Limit  │  Routing  │  Load Balance   │
└──────────────────────┬──────────────────────────────┘
                       │
┌──────────────────────▼──────────────────────────────┐
│              Orchestration Layer                     │
│  Scheduler  │  VM Manager  │  State Store (Redis)   │
└──────────────────────┬──────────────────────────────┘
                       │
┌──────────────────────▼──────────────────────────────┐
│             Compute Layer (EC2 Metal)                │
│  ┌──────┐  ┌──────┐  ┌──────┐  ┌──────┐           │
│  │ VM 1 │  │ VM 2 │  │ VM 3 │  │ VM N │  ...      │
│  │ FC μ │  │ FC μ │  │ FC μ │  │ FC μ │           │
│  └──────┘  └──────┘  └──────┘  └──────┘           │
│            Firecracker microVM Host                  │
└─────────────────────────────────────────────────────┘
                       │
┌──────────────────────▼──────────────────────────────┐
│              Storage & Observability                 │
│  S3 (Snapshots)  │  RDS  │  CloudWatch  │  Kafka   │
└─────────────────────────────────────────────────────┘

Security Model

Security is foundational to Vibe Engine. Every layer is designed for defense in depth.

Isolation Layers

1. Firecracker microVM — Each sandbox runs in its own lightweight VM with a dedicated kernel. This provides the same isolation boundary as a separate physical machine.
2. Network namespace — Sandboxes cannot communicate with each other. Each has its own virtual network interface.
3. Filesystem isolation — Each sandbox has its own ephemeral filesystem. No shared state between sandboxes unless explicitly configured.
4. Resource limits — CPU, memory, disk I/O, and network bandwidth are capped per sandbox to prevent noisy-neighbor effects.
5. Seccomp filters — System call filtering restricts sandboxes to a minimal set of allowed syscalls.

Global Regions

Deploy sandboxes in the region closest to your users for optimal latency.

Compliance

Vibe Engine is designed to meet enterprise security and compliance requirements.

© 2026 VIBE ENGINE LABS PTE. LTD. All rights reserved.
www.vibengine.cloud · hello@vibengine.cloud