Så bygger du Claude Managed Agents med Claude Sonnet 5

Har du någonsin velat köra ett arbetsflöde i stil med Claude Code från ett Python‑skript, där modellen kan arbeta i en hanterad miljö med tillgång till verktyg, filer, färdigheter och instruktioner?

Claude Managed Agents är utformade för just den här typen av arbetsflöde och hjälper dig att bygga agenter som kan utföra flerstegsuppgifter i en kontrollerad miljö.

I den här handledningen visar jag hur du använder Claude Sonnet 5, en aktuell modell från Anthropic som är framtagen för avancerat resonemang, kodning och dataanalys. Den driver agentens förmåga att granska data, använda verktyg, skriva och köra kod samt producera strukturerade utdata.

Du kommer att skapa en Managed Agent, konfigurera dess miljö, ladda upp en CSV‑fil och ge agenten tillgång till verktyg och en XLSX‑färdighet. 

Agenten analyserar datan, genererar Python-, JSON‑ och Excel‑filer, verifierar resultaten och gör de färdiga utdatafilerna tillgängliga för nedladdning.

Om du är helt ny på Claude rekommenderar jag att du först kollar in kursen Claude Code 101.

Vad är Claude Managed Agents?

Claude Managed Agents är Anthropics hanterade ramverk för att köra Claude som en autonom agent. 

I stället för att skriva din egen loop för att skicka uppmaningar, köra verktygsanrop, spara resultat och hantera körningen definierar du agenten och låter Anthropic sköta infrastrukturen. 

Det är utformat för längre, flerstegsuppgifter där modellen kan behöva använda flera verktyg innan arbetet slutförs.

Managed Agents bygger på fyra huvuddelar:

• Agent: den återanvändbara konfigurationen som innehåller modellen, systemprompten, verktyg, MCP‑servrar och färdigheter.
• Miljö: där agenten körs, antingen i Anthropics molnsandlåda eller i din egen självhostade sandlåda.
• Session: en körande instans av agenten som utför en specifik uppgift.
• Händelser: meddelandena, verktygsanropen, resultaten och statusuppdateringarna som utbyts medan sessionen körs.

1. Förutsättningar för din Claude‑agentarbetsyta

För att följa den här handledningen, installera Python 3.12 eller senare och Jupyter Notebook på din dator. Vi använder en Jupyter‑notebook för att skapa, köra och inspektera Managed Agent steg för steg.

Du behöver också ett konto i Anthropic Console. 

Skapa en ny API‑nyckel i Console, lägg till minst 5 $ i API‑krediter och spara nyckeln säkert. 

Managed Agents kan göra flera modell- och verktygsanrop i en enda session, så de kan kosta mer än en vanlig API‑förfrågan.

Lagra nyckeln som en ANTHROPIC_API_KEY miljövariabel i stället för att lägga in den direkt i notebooken eller committa den till GitHub.

För macOS, Linux eller WSL, kör detta i din terminal:

export ANTHROPIC_API_KEY="your-api-key-here"

För Windows PowerShell, använd:

$env:ANTHROPIC_API_KEY="your-api-key-here"

2. Ställ in Anthropics Python‑SDK

Innan vi skapar en Managed Agent installerar du det officiella Anthropics Python‑SDK och importerar de moduler som behövs för den här notebooken. 

SDK:t tillhandahåller klienten Anthropic som du använder för att skapa agenter, miljöer, filer och sessioner. 

%pip install -q --upgrade anthropic

Läs sedan in din Anthropic API‑nyckel från en miljövariabel. 

Att hålla nyckeln utanför notebooken är säkrare än att lägga den direkt i koden, särskilt om du planerar att dela projektet eller pusha det till GitHub.

import os
from anthropic import Anthropic

api_key = os.environ.get("ANTHROPIC_API_KEY")
assert api_key, "Set ANTHROPIC_API_KEY in your environment or in a local .env file."

Managed Agents nås för närvarande via Anthropics beta‑API. Beta‑flaggan managed-agents-2026-04-01 aktiverar denna funktion, även om det officiella SDK:t automatiskt skickar nödvändig beta‑header för förfrågningar till Managed Agents. 

Vi behåller flaggan i notebooken eftersom den senare behövs när vi listar och laddar ner sessionsfiler. 

BETA_FLAG = "managed-agents-2026-04-01"

client = Anthropic(api_key=api_key)

Skapa till sist en ordbok för att lagra ID:n för alla resurser som skapas under handledningen. 

Detta inkluderar agenten, miljön, den uppladdade filen och sessionen. Att spara dessa ID:n gör städningen enklare i slutet, även om ett senare steg misslyckas.

created = {"agent": None, "environment": None, "file": None, "session": None}
print("✓ Anthropic client initialized.")

Klienten är nu redo. 

3. Skapa Managed Agent

En Managed Agent är den återanvändbara konfigurationen för ditt arbetsflöde. 

När du skapar en väljer du Claude‑modellen, skriver systemprompten som definierar dess roll och instruktioner och bifogar de verktyg och färdigheter den kan använda. 

Du kan sedan återanvända samma agent i flera sessioner i stället för att återskapa konfigurationen varje gång. 

Vi döper vår agent till Sonnet 5 Data Analyst och använder claude-sonnet-5. 

Systemprompten säger åt den att uppträda som en noggrann dataanalytiker: inspektera filer monterade i /workspace, använd kodkörning för analys, håll resultaten kortfattade och spara slutliga filer till /mnt/session/outputs.

agent = client.beta.agents.create(
    name="Sonnet 5 Data Analyst",
    model="claude-sonnet-5",
    system=(
        "You are a meticulous data analyst. When asked about data, always read the "
        "file mounted at /workspace, analyse it with the code execution tool, and "
        "report concise, numeric results. Use the XLSX skill for spreadsheet work. "
        "Save final artifacts to /mnt/session/outputs."
    ),
    tools=[
        {"type": "agent_toolset_20260401"},
    ],
    skills=[{"type": "anthropic", "skill_id": "xlsx"}],
)

agent_toolset_20260401 ger agenten tillgång till Anthropics inbyggda verktyg i en session, medan xlsx‑färdigheten ger uppgiftsspecifik vägledning för att skapa och analysera Excel‑arbetsböcker. 

Anthropic tillhandahåller också färdiga färdigheter för PowerPoint‑, Word‑ och PDF‑arbetsflöden.

Spara slutligen agent‑ID:t. 

Du använder det när du skapar en session senare, och det gör också att städningsavsnittet kan arkivera agenten när handledningen är klar.

created["agent"] = agent.id
print(f"✓ Created agent: {agent.id}")

Du bör se en utdata som liknar:

✓ Created agent: agent_01EVcgvQsAkLxNnJFp6aynwm

4. Konfigurera Anthropics molnsandlåda

Därefter skapar vi miljön där Managed Agent körs under en session. 

En miljö fungerar som en säker sandlåda och ger agenten en separat arbetsyta för att läsa monterade filer, skriva kod och köra kommandon.

Vi använder Anthropics molnmiljö med begränsad nätverkstillgång. Agenten använder den här sandlådan senare för att analysera den uppladdade CSV‑filen med Python.

environment = client.beta.environments.create(
    name="code-exec-sandbox",
    config={"type": "cloud", "networking": {"type": "limited"}},
)

created["environment"] = environment.id
print(f"✓ Created environment: {environment.id}")

Efter att ha kört cellen bör du se ett miljö‑ID liknande:

✓ Created environment: env_01FzWACEf9UJDL65ovBPA1zf

5. Ladda upp data med Anthropics Files API

Nu laddar vi upp datasetet som agenten ska analysera. 

Managed Agents använder Anthropics Files API för att ladda upp lokala filer, som sedan kan monteras i sessionsmiljön.

I den här guiden använder vi det exempelbaserade datasetet med 12 rader som heter sales_data.csv. 

Innan vi laddar upp kontrollerar vi att filen finns och bekräftar att den innehåller förväntat antal datarader.

from pathlib import Path

csv_path = Path("sales_data.csv")
assert csv_path.exists(), f"Missing input file: {csv_path.resolve()}"

row_count = sum(1 for _ in csv_path.open(encoding="utf-8")) - 1
assert row_count == 12, f"Expected 12 data rows, found {row_count}"

Sedan laddar vi upp filen och sparar dess ID för senare städning.

uploaded = client.beta.files.upload(file=csv_path)

created["file"] = uploaded.id
print(f"✓ Uploaded {csv_path}: {uploaded.id} ({row_count} rows)")

Efter att ha kört cellen bör du se utdata som liknar:

✓ Uploaded sales_data.csv: file_011Cch3EubJkswPdo3gMBvM2 (12 rows)

6. Initiera en agentsessionskörning

Nu skapar vi en session. 

En session kopplar samman agenten, miljön och de resurser den behöver för en specifik uppgift. Här monterar vi den uppladdade CSV‑filen på /workspace/sales_data.csv så att agenten kan komma åt den inifrån sandlådan.

session = client.beta.sessions.create(
    agent=agent.id,
    environment_id=environment.id,
    resources=[
        {
            "type": "file",
            "file_id": uploaded.id,
            "mount_path": "/workspace/sales_data.csv",
        },
    ],
)

created["session"] = session.id
print(f"✓ Created session: {session.id}")

Du bör se ett sessions‑ID liknande:

✓ Created session: sesn_015mNhrKhqqfe7u8VP6GuFdr

7. Strömma agentens svar

Nu skickar vi uppgiften till sessionen och strömmar agentens aktivitet medan den arbetar. 

Att skapa en session förbereder bara agenten och sandlådan; agenten börjar arbeta först när den tar emot en user.message‑händelse. 

Händelseströmmen låter oss se agentens meddelanden, verktygsanrop och slutliga sessionsstatus i realtid. 

Prompten säger åt agenten att analysera den monterade CSV‑filen, skriva och köra ett Python‑skript, skapa en JSON‑sammanfattning och bygga en Excel‑rapport. 

Vi skapar också tre variabler för att samla agentens text, registrera de verktyg den använder och bekräfta om sessionen avslutas korrekt.

agent_text_parts = []
tools_used = []
final_status = None

with client.beta.sessions.events.stream(session.id) as stream:
    # Send the user message once the stream is open.
    client.beta.sessions.events.send(
        session.id,
        events=[
            {
                "type": "user.message",
                "content": [
                    {
                        "type": "text",
                        "text": (
                            "Use the XLSX skill and analyze /workspace/sales_data.csv. "
                            "Write /mnt/session/outputs/analyze_sales.py, run that Python "
                            "script, and have it create /mnt/session/outputs/summary.json. "
                            "Also create /mnt/session/outputs/sales_report.xlsx with the "
                            "source data, monthly profit, and a summary sheet."
                        ),
                    }
                ],
            }
        ],
    )

    for event in stream:
        etype = getattr(event, "type", None)

        if etype == "agent.message":
            for block in event.content:
                txt = getattr(block, "text", None)
                if txt:
                    print(txt, end="")
                    agent_text_parts.append(txt)

        elif etype == "agent.tool_use":
            name = getattr(event, "name", "<tool>")
            print(f"\n[tool_use] {name}")
            tools_used.append(name)

        elif etype == "session.status_idle":
            final_status = "idle"
            print("\n\n✓ Agent finished; session is idle.")
            break

        elif etype == "session.status_error":
            final_status = "error"
            print("\n✗ Session reported an error.")
            break

print("Tools used:", tools_used)

Under körningen bör du se verktygshändelser som read, bash, write och edit. 

Dessa visar att agenten inspekterar tillgängliga instruktioner och filer, skriver analys‑skriptet, kör det i sandlådan och rättar till problem den hittar.

En session blir inaktiv när agenten inte har mer arbete att göra. I det här exemplet indikerar session.status_idle att uppgiften är slutförd, så vi slutar lyssna på strömmen. 

Anthropic hanterar körning för sina inbyggda verktyg inuti sandlådan; du behöver bara hantera verktygsresultat själv när du använder egna, anpassade verktyg. 

8. Hämta genererade filer och händelsehistorik

När sessionen är klar kan vi granska dess sparade händelsehistorik och ladda ner filerna som agenten skapade. 

Händelsehistoriken ger en fullständig logg över sessionen, inklusive modellförfrågningar, verktygsanrop, verktygsresultat och statusändringar.

history = client.beta.sessions.events.list(session.id, order="asc")

print("--- Session event history ---")
for event in history.data:
    print(event.type)

print(f"({len(history.data)} events total)")

Därefter listar vi filerna som är kopplade till sessionen och laddar ner de filer som är markerade som nedladdningsbara. Filerna sparas lokalt i en mapp med namnet outputs.

import os

os.makedirs("outputs", exist_ok=True)

files = client.beta.files.list(scope_id=session.id, betas=[BETA_FLAG])
downloadable = [f for f in files.data if f.downloadable]

print(f"Found {len(downloadable)} downloadable file(s) for this session.")

downloaded_paths = []

for f in downloadable:
    try:
        content = client.beta.files.download(f.id, betas=[BETA_FLAG])
        local_path = os.path.join("outputs", f.filename)

        content.write_to_file(local_path)
        downloaded_paths.append(local_path)

        print(f"  downloaded {f.id} -> {local_path}")
    except Exception as exc:
        print(f"  skip {f.id}: {exc}")

Till sist kontrollerar vi att alla förväntade utdatafiler laddades ned korrekt:

expected_outputs = {"analyze_sales.py", "summary.json", "sales_report.xlsx"}
downloaded_names = {os.path.basename(path) for path in downloaded_paths}

assert expected_outputs <= downloaded_names, (
    f"Missing expected outputs: {sorted(expected_outputs - downloaded_names)}"
)

Det genererade Python‑skriptet, JSON‑sammanfattningen och Excel‑rapporten finns nu i den lokala mappen outputs.

9. Analysera Python‑, JSON‑ och Excel‑utdata

När agenten slutfört uppgiften laddas de genererade filerna ner till den lokala katalogen outputs/. 

Dessa filer visar att agenten gjorde mer än att returnera ett text‑svar: den skrev och körde kod, skapade strukturerad data och producerade en kalkylbladsrapport som kan granskas separat.

Skärmdumparna nedan visar de tre genererade artefakterna.

Den här filen innehåller analyskoden som agenten skrev och körde, vilket gör arbetsflödet reproducerbart och lätt att granska.

Den här filen lagrar resultaten i ett strukturerat format som kan användas av instrumentpaneler, API:er eller andra program.

Den här Excel‑filen presenterar de månatliga beräkningarna visuellt, med intäkter, kostnader, vinst, marginaler, totaler och ett diagram.

För de 12 raderna i sales_data.csv är de verifierade resultaten:

• Totala intäkter: 32 900 $
• Totala kostnader: 14 750 $
• Total vinst: 18 150 $
• Genomsnittlig månadsvinst: 1 512,50 $
• Bästa månad: december (2 550 $ i vinst)
• Sämsta månad: januari (400 $ i vinst)

Arbetsboken är formelstyrd snarare än att bara förlita sig på hårdkodade värden. 

Under körningen läste agenten instruktionerna i den bifogade XLSX‑färdigheten, skapade arbetsboken, räknade om den med LibreOffice, kontrollerade formlerna och fixade ett cirkelreferensproblem innan uppgiften slutfördes.

10. Städa upp Managed Agent‑API‑resurser

Resurser för Managed Agent finns kvar tills du tar bort dem, så det är viktigt att städa upp när uppgiften är klar. 

Aktiva resurser, särskilt körande sessioner och miljöer, kan fortsätta generera kostnader om de lämnas igång.

En session måste vara inaktiv innan den kan raderas. 

I detta sista steg tar vi bort sessionen, den uppladdade filen och miljön och arkiverar sedan agenten. 

Varje städåtgärd omsluts av en hjälpfunktion så att en misslyckad radering inte stoppar återstående resurser från att tas bort.

def safe(label, fn):
    try:
        fn()
        print(f"✓ deleted {label}")
    except Exception as exc:
        print(f"· could not delete {label}: {exc}")

if created["session"]:
    safe("session", lambda: client.beta.sessions.delete(created["session"]))

if created["file"]:
    safe("file", lambda: client.beta.files.delete(created["file"]))

if created["environment"]:
    safe("environment", lambda: client.beta.environments.delete(created["environment"]))

if created["agent"]:
    safe("agent (archived)", lambda: client.beta.agents.archive(created["agent"]))

print("\n🎉 Cleanup complete. The agent is archived; other resources were deleted.")

Du bör se utdata som liknar:

✓ deleted session
✓ deleted file
✓ deleted environment
✓ deleted agent (archived)

🎉 Cleanup complete. The agent is archived; other resources were deleted.

Det kompletta projektet, inklusive notebook, exempel‑CSV och installationsinstruktioner, finns på GitHub. 

Du kan klona arkivet och köra om notebooken för att återskapa resultaten från den här guiden.

Avslutande tankar

Jag tyckte att Claude Managed Agents var lätta att sätta upp och arbeta med. 

Du skapar en agent, ger den verktyg, färdigheter och en sandlåda, och kör den sedan genom en session. 

Därefter kan den hantera ett komplett arbetsflöde, som att skriva kod, skapa filer, kontrollera sina egna utdata och leverera slutresultatet.

Jag försökte först använda en Modal‑sandlåda eftersom jag ville ha en mer flexibel extern miljö. 

Men installationen blev för komplex för den här guidens omfattning, så jag bestämde mig för att hålla projektet fokuserat på Anthropics hanterade molnsandlåda.

Den största nackdelen för mig var kostnaden. Jag körde det här exemplet två gånger med en liten CSV‑fil med bara 12 rader, och det kostade runt 0,25 $. 

Instrumentpanelen visade debiteringen under modellen, men jag kunde inte hitta en detaljerad uppdelning. För en enkel beräkning och kalkylbladsuppgift känns det dyrt jämfört med mer kostnadseffektiva alternativ med öppen källkod.

Sammantaget visar det här projektet hela arbetsflödet för Managed Agent: skapa en agent, ladda upp en CSV‑fil, köra Python i en hanterad sandlåda, generera JSON‑ och Excel‑rapporter, verifiera utdata, ladda ner filerna och städa upp resurserna efteråt.