Data verkennen in een persistente kernel

Deze gids laat zien hoe je een agent iets duurs één keer laat laden en er daarna meerdere vragen over laat stellen, in plaats van de laadtijd bij elke vraag opnieuw te betalen.

De tool eval draait een persistente interpreter. Variabelen, imports en geladen data blijven tussen aanroepen behouden.

Waarom niet gewoon een script draaien

Een eenmalige python -c betaalt de opzet bij elke vraag. Het laden van een dataframe kost seconden en honderd megabyte; er een grafiek van maken kost milliseconden. Wanneer elke vraag de laadtijd kost, stelt een agent minder vragen dan hij zou moeten — en elk antwoord komt terug als tekst die hij daarna opnieuw moet parsen.

Eén keer laden, dan vragen stellen

Laad data/runs.csv en vertel me de p95-duur per agent.

import pandas as pd
runs = pd.read_csv("data/runs.csv")
len(runs)

De laatste expressie wordt weergegeven zoals een notebook dat doet, zodat len(runs) het aantal rijen rapporteert zonder een print.

Dan, in een aparte aanroep:

runs.groupby("agent")["duration_ms"].quantile(0.95).sort_values()

runs is nog steeds geladen. Een pandas-frame komt terug weergegeven als een tabel in plaats van als een repr.

Grafieken belanden in de chat

import matplotlib.pyplot as plt
runs.groupby("agent")["duration_ms"].mean().plot.bar()

Figuren worden na de cel vastgelegd en als afbeeldingen teruggegeven, die het transcript weergeeft. Jij ziet de grafiek; de agent ook.

Figuren worden na het vastleggen gesloten. Een niet-opgevangen figuur zou ook door de volgende cel opnieuw worden getekend en verzonden, waardoor een sessie van vijf cellen de eerste grafiek vijf keer zou uitsturen.

Geen Jupyter, geen pip, geen installatiestap

De runner is gewoon python3 -u die een regelprotocol over stdio spreekt. Hij implementeert display(), MIME-bundle-dispatch en het vastleggen van figuren zelf, dus hij werkt op elke Python 3 — ook in een sandbox waar installeren nu juist precies is wat de sandbox hoort te voorkomen.

De idiomen die je toch al zou typen

Deze worden herschreven naar gewone code in plaats van een fout te geven:

Wat je typt	Wat er gebeurt
%pip install x	Draait pip en leegt daarna de modulecache, zodat de volgende import het ziet
%cd path	os.chdir
!command	Een opgevangen subproces
%%bash	De rest van de cel als shellscript
%%timeit	1000 getimede runs

Het leegmaken van de %pip-cache is degene die ertoe doet: installeren in een levende interpreter doet niets voor een module die al is geïmporteerd, dus zonder dat is de versie die je net hebt geïnstalleerd niet de versie die draait.

Je eigen tools aanroepen vanuit een cel

paths = tool("find", {"pattern": "**/*.dart", "path": "lib"})
for path in paths.splitlines()[:100]:
    contents = tool("read", {"path": path})
    ...

tool(name, args) gaat weer het eigen toolregister van de agent binnen. Dat betekent dat een cel kan uitwaaieren over honderd bestanden, of kan delegeren via task, zonder dat het model per item een beurt hoeft te besteden.

De brug gaat niet om je beveiligingen heen

Een aanroep via de brug wordt afgehandeld tegen hetzelfde toolregister als een aanroep die het model zelf doet, dus het ActionClass-beleid, goedkeuringsprompts en elke wrapper gelden identiek. Een brug die langs het register heen reikte, zou een gat zijn met precies de vorm van “schrijf een Python-one-liner”.

Een aanroep via de brug pauzeert de time-out van de cel zolang hij loopt. Het budget meet inactiviteit, niet kloktijd — een cel die uitwaaiert naar subagenten en vier minuten wacht, is niet vastgelopen, en hem midden in die uitwaaiering doden zou de volledige toestand van de kernel verliezen.

Opnieuw beginnen

eval(code: "…", reset: true, description: "Start a clean interpreter")

Gooit de interpreter weg en start een schone. Alles wat geladen was, is weg — en dat is precies de bedoeling.

Waar de kernel draait

In de omhulling van het gesprek als die er is, anders op de host.

Een persistente interpreter die wordt aangestuurd door een model dat een niet-vertrouwde repo leest, is precies waarom uitvoering alleen binnen een omhulling bestaat: een eenmalige bash-aanroep eindigt tenminste, terwijl een kernel een shell is die dingen onthoudt.

Hij start geen omhulling op om daar te komen — dezelfde regel die voorkomt dat een rigtab automatisch start. Wil je de kernel omhuld hebben, open dan eerst de shell van het gesprek. Zie Een agent een testmachine geven.

Beperkingen

• Eén cel tegelijk per kernel. Twee cellen die in één interpreter om het snelst racen, zijn twee helften van twee programma’s die in één namespace door elkaar lopen.
• Uitvoer is begrensd. Een cel in een print-lus wordt afgekapt in plaats van het contextvenster te mogen vullen.
• Vier afbeeldingen per cel. Een plot-lus kan per iteratie een figuur uitsturen, en elke afbeelding is een grote vaste kostenpost in het request dat hem meedraagt.
• De kernel sterft mee met de run. Een kernel die na het einde van het gesprek nog een dataframe vasthoudt, is een lek.

Gerelateerd

• Sandbox en beveiliging — wat “omhuld” hier betekent
• Een agent een testmachine geven — de omhulling openen
• Ingebouwde agenttools — de argumenten