Autonomous Agents

Build AI agents that autonomously create, validate, and deploy tools using Akira sandboxes.

The Challenge

Modern AI agents need to execute code. But running arbitrary AI-generated code is dangerous:

Code might be malicious or buggy
Agents could corrupt your systems
No isolation means no safety

The Solution

Akira provides isolated sandboxes where agents can safely:

Generate code
Execute and test it
Iterate until it works
Return verified results

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│  AI Agent   │ ──▶ │   Akira     │ ──▶ │  Verified   │
│  Generates  │     │   Tests     │     │   Tool      │
│    Code     │     │   in VM     │     │             │
└─────────────┘     └─────────────┘     └─────────────┘

Example: Self-Improving Agent

An agent that creates tools as it needs them:

import SandboxSDK from '@akiralabs/sandbox-sdk';
import Anthropic from '@anthropic-ai/sdk';
 
const client = new SandboxSDK({ apiKey: process.env.AKIRA_API_KEY });
const claude = new Anthropic();
 
async function createAndValidateTool(description: string) {
  // Step 1: Generate code
  const response = await claude.messages.create({
    model: 'claude-sonnet-4-20250514',
    messages: [{
      role: 'user',
      content: `Create a Python function that: ${description}. Return only the code.`
    }]
  });
 
  const code = response.content[0].text;
 
  // Step 2: Create sandbox
  const sandbox = await client.sandboxes.create({
    image: 'akiralabs/akira-default-sandbox',
    timeout: 300,
  });
 
  try {
    // Step 3: Upload and test
    await client.sandboxes.upload(sandbox.id, {
      path: '/app/tool.py',
      content: Buffer.from(code),
    });
 
    // Step 4: Run tests
    const result = await client.sandboxes.execute(sandbox.id, {
      command: 'python -m pytest /app/tool.py -v',
      timeout: 60,
    });
 
    if (result.exit_code === 0) {
      console.log('Tool validated successfully!');
      return { success: true, code };
    } else {
      console.log('Tests failed, iterating...');
      // Agent could retry with error context
      return { success: false, error: result.stderr };
    }
  } finally {
    await client.sandboxes.delete(sandbox.id);
  }
}

Example: Tool Discovery Agent

An agent that explores APIs and creates wrappers:

async function discoverAndWrapAPI(apiUrl: string) {
  const sandbox = await client.sandboxes.create({
    image: 'akiralabs/akira-default-sandbox',
  });
 
  try {
    // Explore the API
    const exploration = await client.sandboxes.execute(sandbox.id, {
      command: `curl -s ${apiUrl}/openapi.json | python -m json.tool`,
    });
 
    // Generate wrapper based on schema
    const response = await claude.messages.create({
      model: 'claude-sonnet-4-20250514',
      messages: [{
        role: 'user',
        content: `Create a Python SDK for this API:\n${exploration.stdout}`
      }]
    });
 
    const sdkCode = response.content[0].text;
 
    // Test the generated SDK
    await client.sandboxes.upload(sandbox.id, {
      path: '/app/sdk.py',
      content: Buffer.from(sdkCode),
    });
 
    const test = await client.sandboxes.execute(sandbox.id, {
      command: 'python -c "import sdk; print(dir(sdk))"',
    });
 
    return { sdk: sdkCode, exports: test.stdout };
  } finally {
    await client.sandboxes.delete(sandbox.id);
  }
}

Architecture Pattern

┌─────────────────────────────────────────────────────────┐
│                    Agent Orchestrator                    │
│  ┌──────────────────────────────────────────────────┐   │
│  │                   Planning Layer                  │   │
│  │    "I need a tool to parse CSV files"            │   │
│  └──────────────┬───────────────────────────────────┘   │
│                 │                                        │
│                 ▼                                        │
│  ┌──────────────────────────────────────────────────┐   │
│  │                 Code Generation                   │   │
│  │    LLM generates Python implementation           │   │
│  └──────────────┬───────────────────────────────────┘   │
│                 │                                        │
│                 ▼                                        │
│  ┌──────────────────────────────────────────────────┐   │
│  │              Akira Sandbox Testing                │   │
│  │    Upload → Execute → Validate → Iterate         │   │
│  └──────────────┬───────────────────────────────────┘   │
│                 │                                        │
│                 ▼                                        │
│  ┌──────────────────────────────────────────────────┐   │
│  │                  Tool Registry                    │   │
│  │    Store validated tool for future use           │   │
│  └──────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────┘

Benefits

Safety

All generated code runs in isolated VMs. Even if the AI generates malicious code:

Cannot access your systems
Cannot exfiltrate data
Cannot affect other sandboxes

Iteration Speed

Agents can rapidly test and refine:

Instant sandbox creation
Fast execution feedback
Quick iteration cycles

Reproducibility

Sandboxes provide consistent environments:

Same image = same dependencies
Deterministic execution
Easy debugging

Best Practices

Set Reasonable Timeouts

AI-generated code might have infinite loops. Always set execution timeouts.

Always validate - Never trust generated code without testing
Set timeouts - Prevent runaway executions
Use appropriate images - Match dependencies to task
Clean up - Delete sandboxes after use
Log everything - Track what code was generated and executed

Real-World Applications

Devin-like agents - Autonomous software engineers
Research assistants - Agents that write and run experiments
Data analysts - Agents that explore and transform data
DevOps automation - Agents that create deployment scripts

Next Steps

Learn about parallel processing for scaling agents
Explore coding agents for software development
Review the security model

Security Parallel Processing