Sterowanie pracą Fable 5 przez API: effort, budżet i długi kontekst

👁 115 przeczytań

Zbieram warsztatowe przykłady sterowania wysiłkiem modelu, długością kontekstu i kosztem wieloetapowego zadania. Materiał dotyczy konkretnej wersji Fable 5 oraz konfiguracji opisanej w pierwotnym tekście.

Powiązany materiał: Fable 5 - co to jest, ile kosztuje i czy warto? (2026)

1. Adaptive Thinking - kiedy włączać, kiedy nie

Fable 5 obsługuje wyłącznie adaptywne myślenie (thinking: {type: "adaptive"}). Budżet tokenów (budget_tokens) i tryb wyłączonego myślenia (thinking: {type: "disabled"}) zwracają błąd 400. Jeśli chcesz wyłączyć myślenie - po prostu pomiń parametr thinking w całości.

Kiedy adaptywne myślenie się opłaca:

• Problemy wieloetapowe - algebra, logika, debugowanie złożonego stosu
• Długie zadania agentowe, gdzie model musi planować sekwencję działań
• Zadania wymagające weryfikacji własnych odpowiedzi (code review, analiza danych)

Kiedy je pomijać:

• Klasyfikacja, ekstrakcja, proste Q&A - myślenie tylko podnosi koszt
• Zadania z bardzo niskim effort (np. low), gdzie szybkość ważniejsza niż głębokość
• Gdy chcesz przewidywalnego, krótkiego wyjścia

# Włącz adaptywne myślenie
response = client.messages.create(
    model="claude-fable-5",
    max_tokens=64000,
    thinking={"type": "adaptive"},
    output_config={"effort": "high"},
    messages=[{"role": "user", "content": "Przeanalizuj ten fragment kodu..."}]
)

# Wyłącz myślenie - pomiń parametr
response = client.messages.create(
    model="claude-fable-5",
    max_tokens=4096,
    messages=[{"role": "user", "content": "Sklasyfikuj sentiment: 'Świetny produkt!'"}]
)

Ważna pułapka: domyślnie bloki myślenia są zwracane z pustą treścią (display: "omitted"). Jeśli chcesz widzieć rozumowanie modelu w UI lub logach, dodaj display: "summarized".

thinking={"type": "adaptive", "display": "summarized"}

2. Effort Levels - pięć biegów do wyboru

Parametr effort to kluczowy regulator kosztów i jakości w Fable 5. Działa wewnątrz output_config, nie na poziomie głównym zapytania.

• low - szybkie, krótkie zadania. Klasyfikacja, routing, proste odpowiedzi. Mniej wywołań narzędzi, zwięźlejsze potwierdzenia.
• medium - dobry punkt startowy dla większości zastosowań produkcyjnych. Balans między jakością a kosztem tokenów.
• high - domyślne ustawienie dla zadań wrażliwych na jakość. Minimum dla poważnej pracy agentowej.
• xhigh - najlepszy wybór dla kodowania i zadań agentowych. To ustawienie domyślne w Claude Code.
• max - gdy poprawność jest ważniejsza niż koszt. Testuj przed wdrożeniem - potrafi wykazywać efekt „overthinkingu”.

Przykłady doboru poziomu do zadania

# Routing chatbota - low wystarczy
output_config={"effort": "low"}

# Generowanie raportu z danych - high lub xhigh
output_config={"effort": "high"}

# Agent refaktoryzujący duży projekt - xhigh
output_config={"effort": "xhigh"}

# Walidacja krytycznego algorytmu finansowego - max
output_config={"effort": "max"}

Praktyczna wskazówka: zacznij od high, mierz jakość wyników, schodź do medium gdy rezultaty są wystarczające. Różnica w koszcie między medium a xhigh może być znacząca przy dużej skali.

3. Okno kontekstu 1M tokenów - co wkładać, czego nie

Milion tokenów to około 750 tys. słów - cała trylogia Władcy Pierścieni i jeszcze zostaje miejsca. Ale duży kontekst to nie tylko szansa, to też koszt i ryzyko.

Co warto wkładać do kontekstu:

• Duże bazy kodu do refaktoryzacji lub code review
• Długie dokumenty prawne lub techniczne wymagające spójnej analizy
• Historia konwersacji agenta, gdy ciągłość jest krytyczna
• Zestawy przykładów few-shot dla zadań z domeną specjalistyczną

Czego unikać w kontekście:

• Powtarzających się danych - model nie potrzebuje tego samego dokumentu trzy razy
• Surowych logów bez filtrowania - wgraj tylko istotne fragmenty
• Danych tymczasowych, które model i tak zignoruje (timestamps, UUID-y w środku promptu)
• Kontekstu „na wszelki wypadek” - każdy token kosztuje $10/M przy wejściu

Przy długich dokumentach używaj prompt cachingu. Jeśli ten sam duży kontekst pojawia się w wielu zapytaniach, oznacz go cache_control: {type: "ephemeral"}. Kolejne wywołania kosztują tylko ~0.1x ceny bazowej dla skeszowanej części.

response = client.messages.create(
    model="claude-fable-5",
    max_tokens=64000,
    system=[{
        "type": "text",
        "text": duzy_dokument,
        "cache_control": {"type": "ephemeral", "ttl": "1h"}
    }],
    messages=[{"role": "user", "content": "Podsumuj kluczowe ryzyka prawne"}]
)

4. Task Budgets - budżetowanie tokenów dla agentów

Task Budgets to funkcja beta (nagłówek: task-budgets-2026-03-13) pozwalająca powiedzieć modelowi, ile tokenów ma do dyspozycji na cały cykl pracy. Model widzi licznik odliczający w dół i samoreguluje intensywność działania.

Różnica między task_budget a max_tokens:

• max_tokens - twarde ograniczenie na jedno wywołanie API, model go nie widzi
• task_budget - sugestia dla modelu na cały loop agentowy, model dostosowuje planowanie

response = client.beta.messages.create(
    betas=["task-budgets-2026-03-13"],
    model="claude-fable-5",
    max_tokens=64000,
    thinking={"type": "adaptive"},
    output_config={
        "effort": "high",
        "task_budget": {"type": "tokens", "total": 200000}
    },
    messages=[{"role": "user", "content": "Zrefaktoryzuj cały moduł auth..."}]
)

Minimalna wartość task_budget to 20 000 tokenów. Zbyt niski budżet nie spowoduje błędu - model po prostu wykona zadanie mniej dokładnie, informując o ograniczeniu. Przy długich agentach startuj od 100-200K i obserwuj rzeczywiste zużycie, zanim zaczniesz optymalizować.

5. Mid-Session System Messages

Fable 5 obsługuje wstrzykiwanie wiadomości systemowych w środku konwersacji. Zamiast modyfikować główny prompt systemowy (co unieważnia cache całej historii), możesz dodać {"role": "system", ...} do tablicy wiadomości.

response = client.messages.create(
    model="claude-fable-5",
    max_tokens=16000,
    system=[{
        "type": "text",
        "text": stabilny_prompt_systemowy,
        "cache_control": {"type": "ephemeral"}
    }],
    messages=[
        *historia_konwersacji,
        {"role": "user", "content": "Zatwierdzam zmiany w bazie"},
        {"role": "system", "content": "Tryb auto-zatwierdzania aktywny. Wykonuj zmiany bez potwierdzenia."}
    ],
    extra_headers={"anthropic-beta": "mid-conversation-system-2026-04-07"}
)

Kluczowe zasady:

• Wiadomość systemowa musi następować po wiadomości użytkownika, nie może być pierwsza
• Używaj tego do wstrzykiwania kontekstu operatora, nie do nadpisywania instrukcji użytkownika
• To jedyna metoda, która nie psuje cache-u skeszowanej historii
• Modele nieobsługujące tej funkcji zwrócą błąd 400

6. Generowanie 100K+ tokenów tekstu

Fable 5 obsługuje do 128K tokenów wyjścia - ale tylko przy streamingu. Bez streamingu SDK zgłosi timeout przy dużych wartościach max_tokens.

with client.messages.stream(
    model="claude-fable-5",
    max_tokens=128000,
    thinking={"type": "adaptive"},
    output_config={"effort": "high"},
    messages=[{"role": "user", "content": "Napisz kompletny podręcznik..."}]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)
    final = stream.get_final_message()

Przy generowaniu bardzo długich tekstów warto:

• Podzielić zadanie na sekcje i generować je sekwencyjnie - model ma lepszą kontrolę nad strukturą
• Używać szczegółowego outline’u w prompcie - Fable 5 jest bardziej dosłowny niż poprzednie modele
• Monitorować zużycie przez stream.get_final_message().usage

7. Debugowanie gdy model „nie myśli”

Najczęstsza pułapka: włączasz thinking: {type: "adaptive"}, ale bloki myślenia w odpowiedzi są puste. To nie błąd - to domyślne zachowanie Fable 5 (i Opus 4.7/4.8). Bloki myślenia streamują się, ale ich tekst jest pusty, dopóki nie ustawisz display: "summarized".

# Bez tego - puste bloki myślenia
thinking={"type": "adaptive"}

# Z tym - widoczne podsumowanie rozumowania
thinking={"type": "adaptive", "display": "summarized"}

Inne przyczyny braku myślenia:

• Zbyt niski effort - przy low model rzadko sięga po deep thinking
• Zadanie jest zbyt proste - model adaptuje głębokość myślenia do złożoności
• Brakujący parametr thinking - Fable 5, w przeciwieństwie do starszych modeli, nie włącza myślenia automatycznie

Jeśli chcesz sprawdzić, czy model faktycznie myśli, odczytaj bloki z odpowiedzi:

for block in response.content:
    if block.type == "thinking":
        print(f"Myślenie: {block.thinking[:200]}...")
    elif block.type == "text":
        print(f"Odpowiedź: {block.text}")

8. Triki z effort:xhigh dla programowania

xhigh to domyślne ustawienie w Claude Code i najlepszy wybór do zadań programistycznych. Kilka praktycznych wzorców:

Autonomiczny agent kodowania:

response = client.beta.messages.create(
    betas=["task-budgets-2026-03-13"],
    model="claude-fable-5",
    max_tokens=64000,
    thinking={"type": "adaptive", "display": "summarized"},
    output_config={
        "effort": "xhigh",
        "task_budget": {"type": "tokens", "total": 150000}
    },
    messages=[{"role": "user", "content": """
        Zrefaktoryzuj moduł payment_processor.py:
        1. Wydziel logikę walidacji do osobnej klasy
        2. Dodaj testy jednostkowe
        3. Zachowaj pełną kompatybilność wsteczną
    """}]
)

Wskazówki dla xhigh w kodowaniu:

• Podaj pełną specyfikację zadania w jednym prompcie - model lepiej planuje całościowo niż iteracyjnie
• Ustaw max_tokens na minimum 64K, żeby model miał miejsce na kod + wyjaśnienia
• Przy długich sesjach używaj Task Budgets - bez nich xhigh może spalić budżet na nadmiarowe sprawdzanie
• Fable 5 pyta częściej przy niejednoznacznych zadaniach niż Opus 4.8 - bądź konkretny w wymaganiach

9. Oszczędzanie kosztów przy zachowaniu jakości

Fable 5 kosztuje 2x więcej niż Opus 4.8. Strategia mieszana pozwala unikać niepotrzebnych wydatków:

Pipeline z multiple modeli

# Haiku 4.5 do routingu - $1/$5 za milion
router = client.messages.create(
    model="claude-haiku-4-5",
    max_tokens=256,
    messages=[{"role": "user", "content": f"Sklasyfikuj to zapytanie: {query}"}]
)

# Fable 5 tylko dla zadań wymagających najwyższej inteligencji
if router_result == "complex_analysis":
    response = client.messages.create(model="claude-fable-5", ...)
elif router_result == "standard":
    response = client.messages.create(model="claude-opus-4-8", ...)

Prompt caching dla powtarzającego się kontekstu

Przy $10/M za wejście, cache daje ogromne oszczędności. Skeszowany prefix kosztuje tylko $1/M przy odczycie.

# Stabilny kontekst keszuj z TTL 1h
system=[{
    "type": "text",
    "text": duzy_kontekst_produktu,  # np. 50K tokenów dokumentacji
    "cache_control": {"type": "ephemeral", "ttl": "1h"}
}]
# Pierwsze wywołanie: pełny koszt + 25% za zapis cache
# Kolejne przez godzinę: tylko 10% ceny bazowej dla tej części

Batch API dla zadań asynchronicznych

Batch API daje 50% rabatu. Dla analizy danych, masowego generowania treści lub klasyfikacji - nie potrzebujesz odpowiedzi w czasie rzeczywistym.

batch = client.messages.batches.create(
    requests=[
        {
            "custom_id": f"item-{i}",
            "params": {
                "model": "claude-fable-5",
                "max_tokens": 4096,
                "messages": [{"role": "user", "content": item}]
            }
        }
        for i, item in enumerate(lista_dokumentow)
    ]
)

10. Łączenie Fable 5 z innymi modelami w pipeline

Najefektywniejsza architektura to hierarchia modeli - każdy robi to, w czym jest najlepszy:

• Haiku 4.5 - routing, klasyfikacja, proste ekstrakcje ($1/$5)
• Sonnet 4.6 - standardowe generowanie, umiarkowana złożoność ($3/$15)
• Opus 4.8 - trudniejsze zadania, coding, research ($5/$25)
• Fable 5 - tylko tam, gdzie pozostałe modele zawodzą ($10/$50)

async def smart_pipeline(zadanie: str) -> str:
    # Krok 1: Haiku klasyfikuje złożoność
    klasyfikacja = await haiku_classify(zadanie)

    # Krok 2: Wybór modelu na podstawie klasyfikacji
    if klasyfikacja.zlozonosc == "prosta":
        return await sonnet_answer(zadanie)
    elif klasyfikacja.zlozonosc == "srednia":
        return await opus_answer(zadanie)
    else:
        # Fable 5 z pełną konfiguracją dla najtrudniejszych przypadków
        return await fable_answer(
            zadanie,
            effort="xhigh",
            task_budget=200000
        )

Multiagentowy pipeline z Managed Agents

Dla złożonych zadań agentowych, Fable 5 jako koordynator może delegować do tańszych modeli jako subagentów:

agent = client.beta.agents.create(
    name="Główny Analityk",
    model="claude-fable-5",
    system="Koordynujesz analizę. Deleguj proste zadania do subagentów.",
    tools=[{"type": "agent_toolset_20260401"}],
    multiagent={
        "type": "coordinator",
        "agents": [data_agent.id, research_agent.id]
    }
)

Szybka ściąga - najważniejsze zasady

• Myślenie: tylko adaptive, dodaj display: "summarized" jeśli chcesz je widzieć
• Wyłączenie myślenia: pomiń parametr thinking - nie używaj disabled (błąd 400)
• Streaming: obowiązkowy przy max_tokens > ~16000
• Effort domyślny: high dla większości zadań, xhigh dla kodowania i agentów
• Task Budgets: dla agentów z długim cyklem pracy - minimum 20K tokenów
• Mid-session system: zamiast modyfikować główny prompt - dodaj do tablicy messages
• Koszt: cache + batch + routing to trzy główne dźwignie oszczędności

Tekst powstał z pomocą AI i został zredagowany przez człowieka.

// czytaj dalejModele obiecują milion tokenów kontekstu. Sprawdziłem na trzech procentach i dwa poległyArtykułyGPT-6 Astra Pro: ta sama cena i ten sam kontekst co Astra. Więc co jest inne?ArtykułyGrok 4.6 kontra GPT-5.6 Sol i Fable 5: cztery rundy na żywych zadaniach i rachunek-niespodziankaAI