​

Automated Threat Analysis

AI agents can perform comprehensive security analysis on untrusted code by executing it safely in isolated sandboxes. This approach combines static analysis (performed outside the sandbox) with dynamic behavioral analysis (executed inside sandboxes) to detect threats that pure static analysis might miss, such as runtime exploits, data exfiltration attempts, and malicious network activity.

​

Power of Sandboxes

Sandboxes provide isolated execution environments where potentially malicious code can be safely executed and monitored without any risk to production systems or the agent’s infrastructure. Each analysis runs in complete isolation, allowing agents to observe code behavior—including network requests, file system operations, and process execution—without exposing sensitive data or systems to potential threats. The default sandbox image (avmcodes/avm-default-sandbox) includes Python, Node.js, Go, and essential system tools, enabling analysis across multiple programming languages.

​

Why It Makes Agents Better

Without sandboxes, agents would be limited to static code analysis, which can miss runtime threats, obfuscated malicious code, and dynamic attack patterns. With sandboxes, agents can:

• Execute safely: Run untrusted code in isolated environments without risking production systems or data
• Detect runtime threats: Observe actual code behavior, not just static patterns, catching threats that only manifest during execution
• Multi-language analysis: Analyze code in Python, Node.js, Go, and other languages using the pre-configured sandbox environment
• Parallel analysis: Analyze multiple code samples simultaneously across different sandboxes for faster threat detection
• Behavioral detection: Identify threats through actual execution patterns, detecting data exfiltration, network abuse, and resource exhaustion attacks

This enables security agents to provide comprehensive threat analysis that combines the speed of static analysis with the depth of dynamic execution monitoring.

​

Use Cases

​

CI/CD Security Scanning

Agents integrated into CI/CD pipelines can automatically analyze pull requests and code commits, executing code in sandboxes to detect security threats before they reach production.

​

Third-Party Code Review

Agents can analyze third-party libraries, dependencies, and vendor code by executing them in sandboxes, detecting malicious behavior or security vulnerabilities without trusting the source.

​

Automated Security Audits

Security teams can deploy agents to perform regular security audits on codebases, executing code samples in sandboxes to identify potential threats and generate compliance reports.

​

Scenario: Automated Security Analysis

An agent receives a code sample from a CI/CD pipeline. It performs initial static analysis to identify suspicious patterns, then creates a sandbox and executes the code with monitoring. The agent observes network requests, file operations, and process behavior, detecting an attempt to exfiltrate data to an external server. The agent generates a comprehensive threat report with evidence and recommendations.

​

Implementation: Agentic Threat Analysis Loop

1. Receive Code Sample
   Agent receives code to analyze from repository, user input, or CI/CD pipeline.

2. Static Analysis (Outside Sandbox)
   LLM performs initial static analysis to identify potential threat patterns, suspicious imports, and risky operations.

3. Generate Analysis Scripts
   LLM generates Python/Node.js analysis scripts to execute the code and monitor behavior.

4. Create Analysis Sandbox
   Agent creates isolated sandbox using default image (avmcodes/avm-default-sandbox) with appropriate resources.

5. Execute Code Safely
   Agent executes the code in sandbox with monitoring, capturing network activity, file system operations, process execution, resource usage, and error patterns.

6. Collect Execution Data
   Agent gathers stdout, stderr, exit codes, and any generated artifacts from the sandbox.

7. Analyze Results
   LLM analyzes execution results to identify suspicious network calls, unauthorized file access, process spawning, resource exhaustion attempts, and data exfiltration patterns.

8. Generate Threat Report
   Agent creates comprehensive security report with detected threats, severity levels, evidence from execution, recommendations, and flagged code snippets.

9. Iterate if Needed
   Agent may create additional sandboxes with different test scenarios to validate findings or perform deeper analysis.

​

Example (TypeScript)

import SandboxSDK from '@avmcodes/sandbox-sdk';
import { generateText } from 'ai';
import { openai } from '@ai-sdk/openai';

const client = new SandboxSDK({
  apiKey: process.env['SANDBOX_SDK_API_KEY'],
});

async function analyzeCodeForThreats(code: string, language: string) {
  // Step 1: Static analysis (outside sandbox)
  const staticAnalysis = await generateText({
    model: openai('gpt-4o'),
    prompt: `Analyze this ${language} code for security threats. Identify:
    - Suspicious imports or dependencies
    - Network operations
    - File system operations
    - Process execution
    - Data exfiltration patterns
    
    Code:
    ${code}`,
  });

  // Step 2: Generate analysis script
  const analysisScript = await generateText({
    model: openai('gpt-4o'),
    prompt: `Generate a Python script that executes the following ${language} code safely and monitors:
    - Network requests (intercept with requests library hooks)
    - File operations (track file reads/writes)
    - Process execution (monitor subprocess calls)
    - Resource usage
    
    Code to analyze:
    ${code}`,
  });

  // Step 3: Create analysis sandbox
  const sandbox = await client.sandboxes.create({
    name: 'Threat Analysis Sandbox',
    image: 'avmcodes/avm-default-sandbox', // Default image with Python, Node.js, Go
    resources: {
      cpus: 2,
      memory: 1024,
    },
  });

  try {
    // Step 4: Upload code and analysis script
    await client.sandboxes.upload(sandbox.id, {
      path: '/workspace/code_to_analyze.py',
      content: code,
    });

    await client.sandboxes.upload(sandbox.id, {
      path: '/workspace/analyzer.py',
      content: analysisScript.text,
    });

    // Step 5: Execute analysis
    const result = await client.sandboxes.execute(sandbox.id, {
      command: 'cd /workspace && python analyzer.py',
      timeout: 300,
      env: {
        CODE_FILE: 'code_to_analyze.py',
      },
    });

    // Step 6: Collect execution data
    const executionData = {
      stdout: result.stdout,
      stderr: result.stderr,
      exitCode: result.exit_code,
      status: result.status,
    };

    // Step 7: Analyze results with LLM
    const threatReport = await generateText({
      model: openai('gpt-4o'),
      prompt: `Analyze this execution data for security threats:
      
      Static Analysis Findings:
      ${staticAnalysis.text}
      
      Execution Results:
      ${JSON.stringify(executionData, null, 2)}
      
      Generate a threat report with:
      - Detected threats and severity (Critical/High/Medium/Low)
      - Evidence from execution
      - Specific code patterns flagged
      - Recommendations for remediation`,
    });

    return {
      staticAnalysis: staticAnalysis.text,
      executionData,
      threatReport: threatReport.text,
      threatsDetected: result.exit_code !== 0 || result.stderr.includes('THREAT'),
    };
  } finally {
    // Clean up sandbox
    // Sandbox cleanup would happen here
  }
}

// Example: Analyze multiple code samples in parallel
async function analyzeMultipleSamples(codeSamples: Array<{ code: string; language: string }>) {
  const analysisPromises = codeSamples.map(sample =>
    analyzeCodeForThreats(sample.code, sample.language)
  );

  const results = await Promise.all(analysisPromises);
  
  // Aggregate threats
  const allThreats = results.filter(r => r.threatsDetected);
  return {
    totalAnalyzed: results.length,
    threatsFound: allThreats.length,
    reports: allThreats.map(r => r.threatReport),
  };
}

​

Next Steps

• Integrate with CI/CD pipelines for automated security scanning
• Build threat pattern database for faster detection
• Implement parallel analysis across multiple sandboxes for large codebases
• Add support for analyzing compiled binaries and executables
• Create integration with security information and event management (SIEM) systems