Code Execution

Stacknet supports sandboxed code execution — models can write and run code in isolated containers operated by aISP nodes. This enables data analysis, computation, file generation, and tool building directly within conversations.

How it works


┌───────────────────────────────────────────────┐
│  User Request                                 │
│  "Calculate the prime factors of 1234567890"  │
└──────────────────────┬────────────────────────┘
                       │
                       ▼
┌───────────────────────────────────────────────┐
│  Model writes code                            │
│                                               │
│  def prime_factors(n):                        │
│      factors = []                             │
│      d = 2                                    │
│      while d * d <= n:                        │
│          while n % d == 0:                    │
│              factors.append(d)                │
│              n //= d                          │
│          d += 1                               │
│      if n > 1:                                │
│          factors.append(n)                    │
│      return factors                           │
│                                               │
│  print(prime_factors(1234567890))             │
└──────────────────────┬────────────────────────┘
                       │
                       ▼
┌───────────────────────────────────────────────┐
│  aISP Sandbox Execution                       │
│                                               │
│  ┌─────────────────────────────────────────┐  │
│  │  Container (gvisor/kata)                │  │
│  │  --network none                         │  │
│  │  --cap-drop ALL                         │  │
│  │  4GB memory · 4 CPU · 600s timeout      │  │
│  │                                         │  │
│  │  stdout: [2, 3, 3, 5, 3607, 3803]      │  │
│  │  exit: 0                                │  │
│  └─────────────────────────────────────────┘  │
│                                               │
│  aISP earns tokens for execution              │
│  Deterministic attestation recorded           │
└──────────────────────┬────────────────────────┘
                       │
                       ▼
┌───────────────────────────────────────────────┐
│  Model interprets results                     │
│                                               │
│  "The prime factors of 1,234,567,890 are:     │
│   2 × 3² × 5 × 3607 × 3803"                 │
└───────────────────────────────────────────────┘

Sandbox security

Every code execution runs in a hardened container:

Control	Setting
Runtime	gvisor or kata containers
Network	`--network none` (no internet)
Capabilities	`--cap-drop ALL` (minimal privileges)
Memory	4GB limit
CPU	4 cores
Timeout	600 seconds
Filesystem	Ephemeral (destroyed after execution)

Deterministic attestation

Each execution produces a verifiable attestation:


attestation = SHA-256(
  imageDigest +
  inputHash +
  outputHash +
  exitCode +
  environmentHash
)

Warm pools

aISP nodes maintain warm pools of pre-started containers for sub-second execution startup:


Cold start:  ~2-5 seconds (container creation)
Warm start:  <100ms (pre-warmed container)

Operators who maintain warm pools receive:

Paperwork bonus on execution tasks
Priority routing for sandbox-capable tasks
Reputation boost for consistent availability

Usage

Automatic

Models with code execution capability will automatically write and run code when appropriate:


const response = await client.chat.completions.create({
  model: 'preview',
  messages: [
    { role: 'user', content: 'Generate a chart of Bitcoin prices for the last 30 days' }
  ],
  tools: [{ type: 'code_execution' }],
})