Isolated Firecracker microVM for AI Agents

Secrooq Compute provides secure, hardware-isolated Linux MicroVMs (powered by Firecracker) designed for executing arbitrary agent computations, AI workflows, and antidetect browsing environments.

1. Generate API Keys

Log in to your Secrooq Compute Dashboard, navigate to the Settings tab, and click Create New API Key. Securely store your JWT token; it represents your root tenant credential.

2. Fire Up a Computer

Deploy your first isolated microVM in a single curl call. The instance initializes in less than 150ms.

curl -X POST https://api.secrooq.com/computers \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "autonomous-agent-01",
    "type": "ai_agent",
    "instance_type": "standard-1",
    "image": "ubuntu:24.04"
  }'

Secure Token Auth for Isolated microVMs

All Central API requests must specify your secret tenant JSON Web Token (JWT) in the standard HTTP Authorization header using the Bearer schema.

Authorization: Bearer secrooq-super-secret-jwt-key...

REST API for Browser Automation and Agent Control

Interact directly with the Secrooq Central API. Base URL is: https://api.secrooq.com

Creates and provisions an hardware-isolated Computer.

Request Body

Remote Execution of Shell Commands in microVM

Executes a terminal shell command securely inside the microVM environment and streams standard output/error.

Request Body

curl -X POST https://api.secrooq.com/computers/sb_a1b2c3d4/exec \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"command": "uname -a"}'

Background Process Management in Agent Runtimes

Manage background and foreground processes running inside your computer VM. Useful for executing long-running agent scripts, checking execution states, and terminating runaways.

1. Spawn Process

Spawns a process in the background (default) or foreground inside the computer VM.

Request Body

curl -X POST https://api.secrooq.com/computers/sb_a1b2c3d4/processes \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"command": "python3 agent_loop.py", "background": true}'

2. List Processes

Retrieves process history and current statuses from the computer.

3. Get Process Telemetry

Gets CPU, memory, and state telemetry for a running process.

4. Kill Process

Sends a termination signal (SIGKILL) to terminate a process by PID.

Cron Scheduling for Autonomous Agent Tasks

Register cron-based schedules for automatic command execution within your VM. Perfect for scheduled data scraping, system maintenance, and regular agent polling.

1. Create Schedule

Schedules a command using a standard cron pattern.

Request Body

2. List Schedules

Lists active execution schedules registered for the computer.

3. Delete Schedule

Removes a registered scheduled execution task.

Persistent Block-Level Snapshots for microVM State

Create point-in-time filesystem snapshots of your guest workspace directory and restore from them when needed.

1. Take Snapshot

Compresses current guest workspace files and uploads the snapshot tarball to Encrypted Distributed Object Storage.

Request Body

2. List Snapshots

Lists all point-in-time snapshots created for the computer.

3. Restore Snapshot

Wipes the current workspace and replaces it with files from the chosen snapshot.

Request Body

4. Delete Snapshot

Deletes a snapshot file from Encrypted Distributed Object Storage and removes database metadata.

Edge-Hosted Browser Environments for Automation

Secrooq Compute integrates the Edge-Hosted Browser Rendering API (Browser Run) as a cloud-managed headless browser engine to give long-running agents high-performance, low-latency web automation capabilities. Spawns are rate-limited to a maximum of 5 concurrent sessions per computer (subsequent requests receive a 429 response). Actions on closed or expired sessions automatically return a 404 Not Found response.

To learn more about comparing the Edge-Hosted Browser Rendering to the in-VM Chromium vision engines, view the complete Edge-Hosted Browser Rendering Guide.

1. Start Browser Session

Spawns a new headless browser instance and returns connection endpoint and session id.

Response Sample

{
  "sessionId": "bs_7fa83be0",
  "webSocketUrl": "wss://chrome.edge.secrooq.internal/..."
}

2. Navigate URL

Commands the active tab page to navigate to a target URL.

3. Take Page Screenshot

Captures a PNG screenshot stream of the page. Accepts optional ?fullPage=true.

4. Click Element

Simulates a mouse click on a selector or coordinates.

5. Type Keyboard

Types text using simulated keyboard entry.

6. Evaluate JS Script

Evaluates javascript code on the page and returns JSON output.

7. Close Session

Immediately closes the browser instance and releases edge resources.

API-Driven Remote Computer Control and Framebuffer Streaming

Secrooq Compute provides API-driven PC agent control routes to simulate user input, capture virtual framebuffers, stream guest audio, and monitor hardware telemetry.

1. Screen Capture

Captures the current guest desktop framebuffer as a high-fidelity PNG image.

HTTP Headers

Response JSON (Default)

{
  "computer_id": "sb_a1b2c3d4",
  "image": "iVBORw0KGgoAAAANSUhEUg...",
  "format": "png",
  "timestamp": 1780565000000
}

2. Mouse & Keyboard Inputs

Simulates single or double mouse clicks on the desktop canvas at absolute coordinates.

Request Body

Types text strings directly into focused input elements using the guest keyboard buffer.

Request Body

Sends complex keyboard shortcuts and control keys (e.g. Backspace, Return, Ctrl+C).

Request Body

Simulates mouse wheel scrolls in a chosen direction.

Request Body

Simulates press, drag, and release sequences (e.g. window movements, drag-and-drop, sliders).

Request Body

3. Real-time Audio Streaming

Captures real-time output audio stream played by programs inside the guest VM environment. Output is rate-limited to 10 requests per minute.

Query Parameters

HTTP Headers

Injects audio payloads directly into the guest microphone input buffer. Payload is strictly limited to 10MB. Input is rate-limited to 10 requests per minute.

Request Headers

Request Body (JSON format)

4. Telemetry & Hardware

Inspects CPU load, memory utilization, and disk occupancy inside the guest VM kernel namespace. Rate-limited to 30 requests per minute.

Response Payload

{
  "cpu_percent": 12.4,
  "memory_used_mb": 412,
  "memory_total_mb": 4096,
  "disk_used_gb": 3.1,
  "disk_total_gb": 20.0
}

Web-to-Web Voice Agent

Secrooq Compute provides state-of-the-art Web-to-Web voice sessions, allowing users to establish real-time, low-latency, bidirectional audio streaming between agent loops and the browser engine. By leveraging Durable Objects for session routing and Workers AI models for transcription (Whisper), decision making (GLM), and audio generation (SpeechT5), the system enables seamless conversational control without traditional PSTN telephony hardware.

1. Start Voice Session

Spawns a stateful Durable Object instance that handles real-time PCM audio streaming. Gated to Business and Enterprise plans with the Voice add-on enabled.

Response Sample

{
  "sessionId": "vs_541f9ca7",
  "webSocketUrl": "ws://localhost:8787/computers/sb_43518ea1/voice/sessions/vs_541f9ca7/ws"
}

2. List Active Sessions

Lists all active voice sessions for the given MicroVM.

3. Terminate Session

Gracefully terminates the specified session and stops usage tracking.

4. Send Agent Prompt / Command

Submits a text prompt or transcript to the agent control layer. Integrates with the MicroVM execution channel, running shell commands directly on the microVM if needed, and returning an LLM-summarized reply.

Request Body

{
  "prompt": "Create a file named status.log in my home directory."
}

5. Real-time WebSocket Protocol

Connect to the returned webSocketUrl to stream raw PCM audio bytes. The server returns processed event JSON objects and binary response audio segments:

• Audio Format: Incoming binary audio data must be raw 16-bit signed PCM mono format at a sample rate of 16kHz.
• JSON Events: Broadcasts {"event": "transcription", "text": "..."} for input speech, and {"event": "agent_response", "text": "..."} for synthesized response text.
• Binary Responses: Audio segments are synthesized via SpeechT5 TTS and pushed directly as binary frames.

Session Time-Travel (Fork)

Secrooq Compute provides Business and Enterprise tier users with the ability to instantly clone (fork) a computer session at a specific state, either from a designated snapshot ID or from the running state of a live VM.

1. Fork a Computer

Creates a new computer cloned from the snapshot or current state of an existing computer. Gated to Business and Enterprise plans.

Request Body (Optional)

{
  "snapshot_id": "snap_12345678"
}

If omitted, the platform automatically triggers a synchronous live snapshot using the Durable Object process suspend loop first, and then forks from that live snapshot.

Response Sample (201 Created)

{
  "id": "comp_forked_abc123",
  "name": "cloned-computer-01",
  "type": "ai_agent",
  "instance_type": "standard-1",
  "status": "running",
  "forked_from": "comp_parent_xyz789",
  "forked_from_snapshot": "snap_12345678",
  "created_at": 1780917255680
}

Human-in-the-Loop (HITL) Gates

Ensure guardrails around autonomous agent loops by intercepting critical operations with human verification gates. When an agent requests approval, the computer is paused and blocked from visual interaction, command execution, and file system mutations.

1. Pause Computer

Sets the status of the VM to paused and returns a JWT pause token valid for 1 hour.

Response Sample

{
  "pause_token": "eyJhbGciOi..."
}

2. Resume Computer

Resumes computer execution. Requires either the valid pause_token in the request payload or a user session authorized with computer:write scope.

Request Body

{
  "pause_token": "eyJhbGciOi..."
}

3. Get Human Session Console

Obtains a short-lived token and read-only WebSocket URL to securely mirror the VM console without allowing control hijack.

Response Sample

{
  "token": "hitl_71c6a2...",
  "webSocketUrl": "ws://localhost:8787/computers/comp_123/human-session/ws?token=hitl_71c6a2...",
  "expires_at": 1780918155680
}

4. Submit Human Approval

Stores human approval or rejection in the database for polling by active agent loops.

Request Body

{
  "approved": true,
  "message": "Approved to execute package installation."
}

5. Poll Approvals (for Agents)

Retrieves all approvals submitted for this computer, sorted by date in descending order.

6. Auto-Resume Sweeper Limit

To prevent hanging agent execution, paused sessions automatically timeout after **1 hour** of inactivity, triggering a sweeper sweep that returns the computer to a running state and logs a COMPUTER_AUTO_RESUMED event.

JS/TS SDK for Automating Remote Computers

Integrate Secrooq Compute programmatically into your Node.js or TypeScript applications using our native client library.

Installation

npm install secrooq

Client Initialization & Computer Lifecycle

import { SecrooqClient } from 'secrooq';

const client = new SecrooqClient({ apiKey: 'YOUR_API_TOKEN' });

(async () => {
  // 1. Create a secure MicroVM computer
  console.log('🚀 Provisioning isolated computer...');
  const computer = await client.computers.create({
    name: 'node-agent-01',
    instanceType: 'standard-1',
    image: 'ubuntu:24.04'
  });
  console.log(`Created! ID: ${computer.id}`);

  // 2. Execute shell commands
  console.log('🏃 Running initialization script...');
  const execResult = await computer.exec('npm --version');
  console.log(`npm Version: ${execResult.stdout}`);

  // 3. Manage processes
  console.log('📦 Spawning background agent loop...');
  const processInfo = await computer.processes.create('python3 -m http.server 8080', { background: true });
  console.log(`Background Process PID: ${processInfo.pid}`);

  // 4. Capture virtual framebuffer screenshot
  console.log('📸 Capturing desktop screen...');
  const screenshotBuffer = await computer.screenshot();
  // Buffer can be saved to a file or sent to an LLM vision API

  // 5. Clean up computer resources
  console.log('🧹 Destroying computer...');
  await computer.destroy();
  console.log('Resource released successfully.');
})();

Browser Automation & DOM Extraction

Control the high-performance Edge-Hosted Browser Rendering engine directly using the SDK:

import { SecrooqClient } from 'secrooq';

const client = new SecrooqClient({ apiKey: 'YOUR_API_TOKEN' });

(async () => {
  const computer = await client.computers.get('sb_your_computer_id');
  
  // 1. Start browser session (includes webSocketDebuggerUrl for Puppeteer)
  const session = await computer.browser.createSession();
  console.log(`Browser started: ${session.sessionId}`);
  console.log(`CDP Debugger URL: ${session.webSocketDebuggerUrl}`);

  // 2. Navigate to web page
  await session.navigate('https://news.ycombinator.com');

  // 3. Extract parsed structured DOM content (HTML, Markdown, and Links)
  const dom = await session.extractDom();
  console.log(`Document Title: ${dom.title}`);
  console.log(`Gfm Markdown Length: ${dom.markdown.length}`);
  console.log('Extracted Links:', dom.links.slice(0, 5));

  // 4. Close browser session
  await session.close();
})();

Python SDK Client for Programmable microVMs

Build autonomous Python agents, scraper loops, or multi-computer architectures using our async client SDK.

Installation

pip install secrooq

Asynchronous Client Usage

import asyncio
from secrooq import SecrooqClient

async def main():
    # Initialize client (uses SECROOQ_API_KEY env var if apiKey parameter is omitted)
    client = SecrooqClient(api_key="YOUR_API_TOKEN")

    # 1. Provision microVM
    print("🚀 Spawning agent computer...")
    computer = await client.computers.create(
        name="python-agent-01",
        instance_type="standard-1"
    )
    print(f"Computer spawned! ID: ${computer.id}, Status: ${computer.status}")

    # 2. Run shell command
    res = await computer.exec("python3 --version")
    print(f"Python Version: ${res.stdout.strip()}")

    # 3. File System Access
    # Write file to computer guest
    await computer.files.upload("/app/config.json", '{"debug": true}')
    # Download file back
    content = await computer.files.download("/app/config.json")
    print(f"File content downloaded: ${content}")

    # 4. Schedule standard execution task
    schedule = await computer.schedules.create(
        command="python3 /app/heartbeat.py",
        cron="*/5 * * * *"
    )
    print(f"Cron Schedule registered: ${schedule.id}")

    # 5. Terminate and cleanup
    await computer.destroy()
    print("Computer destroyed.")

if __name__ == "__main__":
    asyncio.run(main())

AI Agent Framework Integrations

Secrooq integrates directly into the modern LLM orchestrations ecosystem including LangChain, CrewAI, and AutoGen.

1. LangChain integration

from langchain.agents import initialize_agent, AgentType
from langchain.chat_models import ChatOpenAI
from secrooq.integrations import SecrooqExecTool

# Initialize standard LangChain execution tool
secrooq_tool = SecrooqExecTool(computer_id="sb_your_computer_id")

llm = ChatOpenAI(temperature=0)
agent = initialize_agent(
    tools=[secrooq_tool],
    llm=llm,
    agent=AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True
)

agent.run("Check the memory usage inside the Secrooq computer computer and return the result.")

2. CrewAI integration

from crewai import Agent, Task, Crew
from secrooq.integrations import SecrooqCrewTool

secrooq_tool = SecrooqCrewTool(computer_id="sb_your_computer_id")

developer = Agent(
    role="Software Engineer",
    goal="Write and verify scripts inside the isolated computer VM",
    backstory="You are an automated developer agent with full terminal execution capabilities.",
    tools=[secrooq_tool],
    verbose=True
)

task = Task(
    description="Write a python script that calculates prime numbers to 1000 and run it in the computer.",
    agent=developer
)

crew = Crew(agents=[developer], tasks=[task])
crew.kickoff()

3. AutoGen Custom Runtime Executor

from autogen import ConversableAgent
from secrooq.integrations import SecrooqAutoGenExecutor

# Create Custom AutoGen Executor linked to the Secrooq Computer
executor = SecrooqAutoGenExecutor(computer_id="sb_your_computer_id")

code_executor_agent = ConversableAgent(
    name="code_executor_agent",
    llm_config=False,
    code_execution_config={"executor": executor},
    human_input_mode="NEVER"
)

# Any code blocks generated in conversation with code_executor_agent
# will be executed inside the secure, isolated Secrooq microVM.

📦 How to Create & List an Agent in the Catalog

No file upload required. Build a Docker image of your agent, push it to a public registry like Docker Hub, and submit the image tag to Secrooq. Once approved, Pro and Business customers can rent your agent and you earn 80% of every session.

Step 1 — Build your agent locally

Create a Dockerfile that defines your agent's environment. Example for a Python agent:

FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY agent.py .
CMD ["python", "agent.py"]

Then build the image locally:

docker build -t yourusername/your-agent-name:v1 .

Step 2 — Push the image to a public registry

Use Docker Hub, GitHub Container Registry, or any public container registry.

docker login
docker push yourusername/your-agent-name:v1

Step 3 — Submit the image tag in Secrooq

Go to Developer Workspace → Package VM Template and fill in:

Click Upload VM Listing. Your submission enters the admin approval queue.

Step 4 — Admin approval & publishing

Once an admin approves your listing, it appears in the Catalog for all Pro and Business customers to rent. You'll see the status update in your Managed Agent Listings table.

Step 5 — How customers use your agent

Customers click Get Agent → the agent appears in their installed list → they launch a computer. Secrooq automatically pulls your Docker image, runs it inside a secure microVM, and tracks every second of usage.

💰 How earnings work

Every hour the agent runs, you earn 80% of the hourly price (minus Stripe fees). The formula is:

earnings = price_per_hour × (seconds_used / 3600) × 0.80

Earnings are batched and transferred to your Stripe Express account hourly when your balance exceeds $0.50.

🧪 Test your agent before listing

Run the image locally to verify it works before submitting:

docker run -it --rm yourusername/your-agent-name:v1

For a full test inside a Secrooq computer, ask an admin to use the Test Drive feature from the Admin Portal.

❓ Catalog FAQ

Pricing, Quotas & Support SLAs

Secrooq Compute provides highly scalable, isolated cloud hardware computers with predictable overage pricing and dedicated response SLAs.

Platform Plans & Resource Quotas

Accrued Overage Rates

Resource usage exceeding default allocations is automatically calculated in arrears and billed at the end of the monthly billing cycle:

• VM Hour Overage:
  • standard-1: $0.15 per additional hour.
  • standard-2: $0.15 per additional hour.
  • standard-3: $0.20 per additional hour.
  • standard-4: $0.30 per additional hour.
• computer run overage: $0.0001 per additional run.
• Storage expansion: $0.10 per additional GB.
• AI Chat limits: $0.01 per chat message (on Free tier beyond 1,000 runs).

Secrooq AI Control Plane

Manage your microVM container clusters, classifications, and egress credentials directly via natural language or fast slash commands.

Edge AI Architecture

Secrooq AI uses a resilient multi-model failover system, fallback pipelines, semantic conversation recall, and Vectorize storage:

• Semantic Context Memory: Translates chat logs into 384-dimensional vectors using @cf/baai/bge-small-en-v1.5, referencing relevant contexts instantly from Vectorize.
• Failover Chain: In case of model exhaustion or API timeout, prompts automatically cascade from GLM-4.7-Flash to Kimi-K2.6 and finally to DeepSeek-R1.

AI Hub Slash Commands

Programmatic API Keys

Issue scoped credentials with configurable lifetimes to manage resources from your custom terminal pipelines.

Key Creation & Hashing

API keys are securely generated with a custom array of scopes (e.g. ["computer:create", "computer:read"]) and expiration times (30, 60, 90 days, or unlimited). The raw key prefix sqc_ is displayed once; rest values are encrypted at rest using SHA-256 edge validations.

curl -X GET https://api.secrooq.com/computers \
  -H "Authorization: Bearer sqc_yourkeyhere..."

Model Context Protocol (MCP) Server

Secrooq Compute runs an MCP-compliant endpoint allowing cursor IDEs and Anthropic Claude clients to query VM statuses durably.

MCP Endpoint Details

• Host Connection: mcp.secrooq.com/mcp (unauthenticated hits return 401 Unauthorized status).
• Protocol Actions: Exposes dynamic tools mapping:
  • list_computers: Fetches all running Firecracker computers.
  • create_computer: Allocates a new standard-1 or standard-2 container.
  • execute_computer_command: Runs terminal instructions in computer guest environment.

Outbound Egress Security (Nilbox Pattern)

Protect your production credentials from exposure or leak within container code using the Nilbox Credential Scrubber.

How Nilbox Works

The egress security gateway intercepts all outbound HTTP traffic initiated from computeres:

1. Developers write mock/dummy keys inside computer code (e.g. sk-dummy-openai).
2. The edge gateway catches mock values and dynamically replaces them with real secrets stored in KV vaults.
3. Egress mapping headers (e.g., X-Secrooq-Tenant-Id) are scrubbed, completely shielding internal system topologies.

Enterprise Security & Compliance (SOC2)

Secrooq Compute provides enterprise-grade compliance, security gating, and threat intelligence controls.

1. Vision Agent Control Loop

Manage, click, type, and render screenshots/PDFs on isolated virtual displays with audit trails logged for compliance:

• GET /computers/:id/screenshot: Capture virtual framebuffer.
• POST /computers/:id/click: Double/single mouse click simulator.
• POST /computers/:id/type: Direct injection-proof character typist.
• POST /computers/:id/key: Trigger control keyboard keystrokes.
• POST /computers/:id/pdf: Compile layout-safe guest-side HTML to PDF via WeasyPrint.

2. Malware Threat Shield

A dual-path static scanner blocks ingress uploads and egress download streams containing infected signatures (e.g. EICAR test string) instantly, raising alerts to security@secrooq.com.

3. Short-Lived Scoped Credentials

Clients request path-scoped temporary object storage access tokens valid for 1 hour to read, write, and delete files inside computer-{id}/ directory prefix safely.

4. Human Approvals Gateway

Restricted actions (like egressing to non-allowlisted API domains) require admin sign-off. Approved requests dynamically inject clearances to local KV bypass caches.