Prima ta sarcină de agent într-un sandbox: un LLM scrie cod, o microVM îl rulează

Un agent care scrie cod e util doar dacă ceva rulează acel cod în siguranță și raportează înapoi. Ghidul ăsta construiește bucla cap-coadă: un model scrie un script Python, un sandbox îl rulează, iar dacă eșuează, eroarea se întoarce la model. Apoi aceeași sarcină fără să scrii niciun cod, prin MCP.

Îți trebuie Python 3.8+, un token de cont EQVPS (vezi conectarea contului) și o cheie API pentru un model.

1. Setează întâi un plafon de cheltuieli

Un agent creează singur sandboxuri, așa că dă-i un plafon înainte să înceapă. Doi dolari pe zi și douăzeci pe lună ajung din plin pentru experimente:

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}'

Când un plafon e atins, sandboxurile noi primesc 429 budget_exceeded, iar cele efemere care rulează sunt șterse. Detaliile sunt în limitele și facturarea sandboxurilor.

2. Instalează cele două biblioteci

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

Exemplul folosește un anumit furnizor de modele, dar nimic nu depinde de el. Doar funcția ask() vorbește cu modelul.

3. Bucla scrie, rulează, repară

Salvează asta ca 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."},
        ]

Rulează-l:

python3 agent.py

O rulare obișnuită afișează attempt 1: exit code 0, apoi 78498. Dacă primul script eșuează, vei vedea a doua încercare, cu eroarea reparată.

Ce face fiecare parte:

• Sandbox.create(..., idle_timeout=120) pornește o microVM în aproximativ o secundă. Dacă scriptul tău moare la jumătate, sandboxul se șterge oricum singur după 2 minute de inactivitate.
• sb.run(code, timeout=55) rulează codul și returnează codul de ieșire, stdout și stderr. O cădere a codului e un rezultat normal, nu o excepție, deci bucla i-o poate arăta modelului.
• r.stderr[-3000:] trimite doar finalul erorii. Un traceback complet dintr-un script mare poate risipi mult din contextul modelului.
• Trei încercări e o limită deliberată. Un model care n-a reparat un script din trei încercări are de obicei nevoie de o descriere mai bună a sarcinii, nu de o a patra încercare.

4. Când sarcina are nevoie de mai mult de 55 de secunde

Un apel sincron poate rula cel mult 55 de secunde. Pentru muncă mai lungă, pornește-o în fundal și așteaptă:

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

Sarcina rulează în continuare chiar dacă wait-ul tău expiră și o poți relua cu sb.task(task_id).

5. Aceeași sarcină prin MCP, fără cod

Dacă folosești un client MCP, ca Claude Desktop sau Cursor, cu serverul MCP EQVPS, agentul are deja uneltele de sandbox: create_sandbox, run_code, exec_command, upload_file, download_file și kill_sandbox. Ajunge un prompt:

Creează un sandbox efemer mic. Scrie un script Python care numără numerele prime sub 1.000.000, rulează-l acolo, repară-l dacă eșuează, spune-mi rezultatul și șterge sandboxul.

Agentul face aceleași apeluri ca scriptul de mai sus. Ce unelte e sigur să permiți fără confirmare e explicat în MCP guardrails.

Cât a costat

Sandboxul a trăit mult sub un minut și a fost facturat la minimul de 60 de secunde: $0.00055 pe small. Apelul la model costă mai mult decât sandboxul. Creditul de probă de $1 al unui cont nou acoperă în jur de 1.800 de rulări ca aceasta.

Încotro mai departe

• SDK-ul pas cu pas: SDK de sandbox Python în 5 minute sau TypeScript.
• Fiecare metodă și eroare: referința SDK.
• Tarifele și proba: pagina sandboxurilor.