W tym miesiącu przeczytałeś pewnie z tuzin postów "Agenci AI już tu są!". Anthropic wypuścił Managed Agents 8 kwietnia. Google odpalił ADK. OpenAI wypchnął swoje Agents SDK. Każdy pitch deck rzuca "autonomicznymi agentami" jak zaklęciem. Ale nigdy nie zbudowałeś faktycznej pętli, która napędza je wszystkie — tych 50 linijek Pythona, gdzie model wywołuje funkcję, czyta wynik i decyduje, co dalej. Bez tego każde vendorowe demo wygląda równie imponująco, a ty nie odróżnisz prawdziwej funkcjonalności od drogiego opakowania na prezent.

Dlaczego "po prostu użyj platformy" nie działa

Oczywisty ruch: wybierz zarządzaną platformę i niech ona ogarnie wszystko. Ale jest problem — oddajesz zrozumienie w outsourcing. Anthropic Managed Agents kasuje $0.08 za godzinę sesji. OpenAI Agents SDK ma własne abstrakcje. Google ADK używa workflow opartych na grafach. Każda platforma opakowuje ten sam wzorzec w różne opinie o pamięci, uprawnieniach i rozliczeniach — ale jeśli nie znasz samego wzorca, nie jesteś w stanie ocenić, które opinie mają znaczenie w TWOIM przypadku. Analiza MIT Sloan Management Review z 2024 roku pokazuje, że wskaźnik sukcesu wdrożeń agentycznego AI z pilota do produkcji wynosi około 5%. Problemem nie jest framework. Problemem są zespoły, które nie rozumieją, co jest pod spodem.

Więc zbudujmy to.

Przepis: 50 linijek na rentgen

Krok 0: Zainstaluj SDK

Na 27 kwietnia 2026 roku najnowsza wersja Anthropic Python SDK — zestawu narzędzi pozwalającego Twojemu Pythonowi gadać z mózgiem Claude'a — to v0.97.0. Jedna komenda:

pip install anthropic

Ustaw klucz API — tajne hasło, które identyfikuje Twoje konto na serwerach Anthropic:

export ANTHROPIC_API_KEY="sk-ant-..."

Krok 1: Zdefiniuj narzędzia

Narzędzia to funkcje, które Claude może poprosić cię o uruchomienie. Opisujesz je za pomocą JSON Schema — ustandaryzowanego formatu mówienia "ta funkcja przyjmuje takie dane wejściowe o takich kształtach". Claude czyta te opisy jak menu w restauracji i wybiera, co zamówić.

Kluczowy insight: opisy są ważniejsze niż nazwy. Claude decyduje kiedy wywołać narzędzie na podstawie tego, co mówi opis. Niejasny opis = nieprzewidywalne zachowanie.

Oto prawdziwa definicja narzędzi — sprawdzanie pogody i tworzenie wydarzeń w kalendarzu:

tools = [
    {
        "name": "get_weather",
        "description": "Get current weather for a city. Use when the user asks about weather, temperature, or outdoor conditions.",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {"type": "string", "description": "City name, e.g. 'New York'"},
                "units": {"type": "string", "enum": ["celsius", "fahrenheit"]}
            },
            "required": ["city"]
        }
    },
    {
        "name": "create_event",
        "description": "Create a calendar event. Use when the user wants to schedule, book, or plan something.",
        "input_schema": {
            "type": "object",
            "properties": {
                "title": {"type": "string"},
                "start": {"type": "string", "format": "date-time"},
                "end": {"type": "string", "format": "date-time"}
            },
            "required": ["title", "start", "end"]
        }
    }
]

Zwróć uwagę: required kontroluje zachowanie. Pomiń wymagane pole, a Claude zacznie halucynować wartości. Dodaj za dużo wymaganych pól, a poprawne wywołania zostaną zablokowane.

Krok 2: Zbuduj warstwę wykonawczą

Tu działa TWÓJ kod. Claude nigdy sam niczego nie uruchamia — wysyła grzeczną prośbę typu "proszę, uruchom get_weather z {city: 'Chicago'}", a Twój kod robi faktyczną robotę:

def run_tool(name, input_data):
    if name == "get_weather":
        # W produkcji tutaj wywołałbyś API pogodowe
        return {"temp": 72, "condition": "sunny", "city": input_data["city"]}
    if name == "create_event":
        return {"event_id": "evt_456", "status": "created", "title": input_data["title"]}
    return {"error": f"Unknown tool: {name}"}

Krok 3: Pętla — tu rodzi się agencja

To jest ta część, którą każda platforma opakowuje w tysiące linii abstrakcji. Pętla agentyczna — cykl, w którym Claude wywołuje narzędzia, czyta wyniki i decyduje o następnym ruchu — to jakieś 20 linijek:

import json
import anthropic

client = anthropic.Anthropic()
messages = [{"role": "user", "content": "What's the weather in Chicago? If it's nice, schedule a picnic tomorrow at noon."}]

response = client.messages.create(
    model="claude-sonnet-4-20250514", max_tokens=1024,
    tools=tools, messages=messages
)

while response.stop_reason == "tool_use":
    # Claude może żądać WIELU narzędzi naraz — przetwarzamy WSZYSTKIE
    tool_results = []
    for block in response.content:
        if block.type == "tool_use":
            result = run_tool(block.name, block.input)
            tool_results.append({
                "type": "tool_result",
                "tool_use_id": block.id,
                "content": json.dumps(result)
            })

    messages.append({"role": "assistant", "content": response.content})
    messages.append({"role": "user", "content": tool_results})

    response = client.messages.create(
        model="claude-sonnet-4-20250514", max_tokens=1024,
        tools=tools, messages=messages
    )

print(response.content[0].text)

Ten prompt wywołuje DWA autonomiczne wywołania narzędzi: najpierw get_weather (sprawdzenie Chicago), potem create_event (zaplanowanie pikniku) — a Claude łączy je sam, bez twojej ingerencji. To jest moment "aha": model czyta wynik pogody, sam ocenia, że jest ładnie, i sam odpala następne narzędzie.

Każda platforma agentowa to ta pętla plus opinie o pamięci, uprawnieniach, rozliczeniach i deploymencie nałożone na wierzch.

Krok 4: Obsługa błędów — nie crashuj, ucz

Kiedy narzędzie się wysypie, nie zabijaj pętli. Wyślij błąd z powrotem z flagą is_error: True, żeby Claude mógł się zaadaptować — spróbować z innymi danymi, wyjaśnić problem albo pójść inną drogą:

def run_tool_safe(name, input_data):
    try:
        return run_tool(name, input_data), False
    except Exception as e:
        return {"error": str(e)}, True

# Wewnątrz pętli zamień budowanie tool_results:
result, is_err = run_tool_safe(block.name, block.input)
tool_results.append({
    "type": "tool_result",
    "tool_use_id": block.id,
    "content": json.dumps(result),
    "is_error": is_err
})

Claude czyta błąd i reaguje inteligentnie: "Próbowałem zaplanować piknik, ale kalendarz pozwala tylko na wydarzenia w godzinach pracy. Chcesz, żebym spróbował w sobotę rano?"

Krok 5: Dodaj bezpiecznik

Niekontrolowana pętla pali tokeny — małe kawałki tekstu, które Claude przetwarza, mniej więcej ¾ angielskiego słowa każdy — dopóki jej nie zabijesz. Dodaj licznik:

MAX_ITERATIONS = 10
iteration = 0

while response.stop_reason == "tool_use" and iteration < MAX_ITERATIONS:
    iteration += 1
    # ... to samo ciało pętli ...

if iteration >= MAX_ITERATIONS:
    print("Pętla osiągnęła limit bezpieczeństwa. Coś pewnie poszło nie tak.")

Żadna zarządzana platforma ci nie powie, że to pierwsza rzecz do dodania. Obsługują to po cichu — i kasują cię za ten przywilej.

Pułapki, które gryzą na produkcji

1. Bug "tylko pierwsze narzędzie". Claude może zwrócić wiele bloków tool_use w jednej odpowiedzi — np. sprawdzanie pogody w trzech miastach jednocześnie. Jeśli przetworzysz tylko pierwszy blok (częsty błąd w tutorialach), model się gubi przez brakujące wyniki. Objaw: Claude ciągle powtarza to samo żądanie. Rozwiązanie: iteruj po WSZYSTKICH blokach, zwracaj WSZYSTKIE wyniki w jednej wiadomości. Oficjalny tutorial nazywa to progresją Ring 2 → Ring 3.

2. Puchnięcie okna kontekstu. Okno kontekstu — ile tekstu Claude "widzi" naraz, jak pamięć robocza — zapełnia się szybko. Każde wywołanie narzędzia i wynik się kumuluje. Gadatliwy output komendy może pożreć tysiące tokenów w jednej turze. Agent SDK obsługuje kompakcję automatycznie; surowe SDK nie. Rozwiązanie: streszczaj duże outputy przed zwróceniem ich modelowi albo przytnij do istotnych fragmentów.

3. Brak sandboxingu. Twoja funkcja run_tool działa z TWOIMI uprawnieniami. Jeśli Claude poprosi o usunięcie pliku i twoje narzędzie posłucha, plik znika. Według analizy Momentic, ich zespół nauczył się tego boleśnie przez 3 miesiące autonomicznych uruchomień agentów: "sandboxing nie jest opcjonalny... sytuacja wymyka się z rąk szybciej, niż myślisz."

4. Brakujące pola required. Jeśli twój schemat mówi required: ["city"], ale użytkownik pyta "jaka pogoda?", Claude zahalucynuje miasto zamiast dopytać. Rozwiązanie: sprecyzuj opis — "Jeśli użytkownik nie podał miasta, zapytaj go zamiast zgadywać."

Co możesz zrobić teraz

Masz działającą pętlę agentyczną. Każdy vendorowy announcement od teraz mapuje się bezpośrednio na nią. Managed Agents? To twoja pętla plus checkpointing, monitoring i crash recovery — za $0.08/godzinę sesji. OpenAI Agents SDK vs Google ADK? Ta sama pętla, inne opinie o handoffach i grafowych workflow.

Następny pitch platformowy ląduje na twoim biurku. Zamiast wierzyć demo, pytasz: którą warstwę MOJEJ pętli to zastępuje — i czy ta warstwa to faktycznie moje wąskie gardło?