Il tuo primo task da agente in una sandbox: un LLM scrive il codice, una microVM lo esegue

Un agente che scrive codice è utile solo se qualcosa esegue quel codice in sicurezza e riporta il risultato. Questa guida costruisce quel ciclo dall'inizio alla fine: un modello scrive uno script Python, una sandbox lo esegue e, se fallisce, l'errore torna al modello. Poi lo stesso task senza scrivere codice, via MCP.

Ti servono Python 3.8+, un token dell'account EQVPS (vedi collegare l'account) e una chiave API per un modello.

1. Prima imposta un tetto di spesa

Un agente crea sandbox da solo, quindi dagli un tetto prima che inizi. Due dollari al giorno e venti al mese bastano e avanzano per sperimentare:

curl -X PUT https://api.eqvps.com/api/v1/eqvps/sandboxes/budget \
  -H "Authorization: Bearer $EQVPS_API_KEY" -H "Content-Type: application/json" \
  -d '{"daily_usd": 2, "monthly_usd": 20}'

Quando si raggiunge un tetto, le nuove sandbox ricevono 429 budget_exceeded e quelle effimere in corso vengono eliminate. I dettagli sono in limiti e fatturazione delle sandbox.

2. Installa le due librerie

pip install eqvps anthropic
export EQVPS_API_KEY="your-eqvps-token"
export ANTHROPIC_API_KEY="your-model-key"

L'esempio usa un fornitore di modelli, ma niente dipende da lui. Solo la funzione ask() parla con il modello.

3. Il ciclo scrivi, esegui, correggi

Salva questo come agent.py:

import re
import anthropic
from eqvps import Sandbox

TASK = "Count the prime numbers below 1,000,000 and print only the number."
client = anthropic.Anthropic()

def ask(messages):
    msg = client.messages.create(model="claude-sonnet-5", max_tokens=2000, messages=messages)
    return msg.content[0].text

def extract_code(text):
    m = re.search(r"`{3}(?:python)?\n(.*?)`{3}", text, re.S)
    return m.group(1) if m else text

messages = [{"role": "user", "content": "Write a Python 3 script for this task. "
             "Reply with a single code block and nothing else.\n\nTask: " + TASK}]

with Sandbox.create(tariff="small", idle_timeout=120) as sb:
    for attempt in range(1, 4):
        reply = ask(messages)
        r = sb.run(extract_code(reply), timeout=55)
        print(f"attempt {attempt}: exit code {r.exit_code}")
        if r.ok:
            print(r.stdout.strip())
            break
        messages += [
            {"role": "assistant", "content": reply},
            {"role": "user", "content": f"The script failed with exit code {r.exit_code}.\n"
             f"stderr:\n{r.stderr[-3000:]}\nFix it. Reply with a single code block."},
        ]

Eseguilo:

python3 agent.py

Un'esecuzione tipica stampa attempt 1: exit code 0 e poi 78498. Se il primo script fallisce, vedrai il secondo tentativo con l'errore corretto.

Cosa fa ogni parte:

• Sandbox.create(..., idle_timeout=120) avvia una microVM in circa un secondo. Se il tuo script muore a metà, la sandbox si elimina comunque da sola dopo 2 minuti di inattività.
• sb.run(code, timeout=55) esegue il codice e restituisce codice di uscita, stdout e stderr. Un crash nel codice è un risultato normale, non un'eccezione, quindi il ciclo può mostrarlo al modello.
• r.stderr[-3000:] invia solo la fine dell'errore. Un traceback completo di uno script grande può sprecare molto contesto del modello.
• Tre tentativi sono un limite voluto. Un modello che non ha sistemato uno script in tre tentativi di solito ha bisogno di una descrizione migliore del task, non di un quarto tentativo.

4. Quando il task richiede più di 55 secondi

Una chiamata sincrona dura al massimo 55 secondi. Per lavori più lunghi, avviali in background e aspetta:

task = sb.run(code, background=True)
result = task.wait(timeout=1800)

Il task continua anche se il tuo wait va in timeout, e puoi riprenderlo con sb.task(task_id).

5. Lo stesso task via MCP, senza codice

Se usi un client MCP come Claude Desktop o Cursor con il server MCP di EQVPS, l'agente ha già gli strumenti per le sandbox: create_sandbox, run_code, exec_command, upload_file, download_file e kill_sandbox. Basta un prompt:

Crea una piccola sandbox effimera. Scrivi uno script Python che conti i numeri primi minori di 1.000.000, eseguilo lì, correggilo se fallisce, dimmi il risultato ed elimina la sandbox.

L'agente fa le stesse chiamate dello script qui sopra. Quali strumenti consentire senza conferma è spiegato in protezioni MCP.

Quanto è costato

La sandbox è vissuta ben meno di un minuto ed è stata fatturata al minimo di 60 secondi: 0,00055 $ su small. La chiamata al modello costa più della sandbox. Il credito di prova da 1 $ di un nuovo account copre circa 1.800 esecuzioni come questa.

Dove andare dopo

• L'SDK passo per passo: SDK Python per sandbox in 5 minuti o TypeScript.
• Tutti i metodi e gli errori: riferimento dell'SDK.
• Tariffe e prova: la pagina delle sandbox.