Claude Fable 5 API-tutorial: bouw een Developer Task Assistant in Python

Update (1 juli 2026): De toegang tot Claude Fable 5 is hersteld en nu wereldwijd beschikbaar op Claude Platform, Claude.ai, Claude Code en Claude Cowork nadat het exportbevel is opgeheven. Mythos 5 blijft beperkt tot gescreende Project Glasswing-partners.

Update (2 september 2026): Anthropic heeft het opvolgmodel van Fable 5 gepubliceerd. Ik raad je aan onze gids Claude Fable 5.1 te lezen voor alle details.

Als ik een nieuw model via een API test, geef ik minder om de launch-notes en meer om de onderdelen die ik in code moet aansluiten: hoe ziet de API-call eruit, wat is er veranderd ten opzichte van het vorige model, hoeveel kost het, en wat gebeurt er als de safetylaag nee zegt?

Ons overzichtsartikel over Claude Fable 5 behandelde de lancering, benchmarkresultaten en de safety-setup die Fable 5 uniek maakt. De code hieronder pakt het daar op. We gebruiken specifiek een Developer Task Assistant die een software-feature request aanneemt en een gestructureerd implementatieplan teruggeeft, en voegen daarna streaming, toolgebruik, kostentracking en een FastAPI-endpoint toe.

We lopen door:

• Een Fable 5 API-call maken en het antwoord lezen
• Het model sturen met een system prompt
• JSON teruggeven met gestructureerde outputs
• Lange antwoorden streamen naar een terminal of webclient
• Een simpele tool koppelen en de tool-loop draaien
• Tokencosts schatten en bijhouden vóór en na elke request
• Weigeringen afhandelen zonder dat je applicatie crasht
• Afbeeldingsinputs verwerken voor UI-review of visuele analyse
• De hele workflow aanbieden via een FastAPI-endpoint

Wat is Claude Fable 5?

Claude Fable 5 is een Anthropic-model dat op 9 juni 2026 is uitgebracht, met de API-modelstring claude-fable-5. Anthropic beschrijft het als hetzelfde basismodel als Claude Mythos 5, maar met toegepaste safety-classifiers voor algemene beschikbaarheid. Mythos 5 blijft beperkt tot Project Glasswing, een beperkt programma voor vertrouwde securityorganisaties.

Voor developers zijn de relevante API-details:

• Een contextwindow van 1M tokens en tot 128k outputtokens per request

• Geprijsd op $10 per miljoen inputtokens en $50 per miljoen outputtokens, het dubbele van Opus 4.8

• Adaptive thinking staat altijd aan. Je kunt het niet uitschakelen. De effort parameter bepaalt de diepte; de interne redenering van het model wordt gegenereerd en gefactureerd, ongeacht of je die toont

• Het is een "Covered Model", wat betekent dat 30 dagen dataretentie verplicht is. Zero Data Retention is voor dit model niet beschikbaar.

Ik zou het niet voor elke API-call gebruiken. Het is logischer voor taken die redenering over architectuur, randgevallen en implementatiedetail vereisen. Voor eenvoudiger werk zijn Sonnet 4.6 of Haiku 4.5 waarschijnlijk genoeg.

Wat we bouwen met Fable 5: een Developer Task Assistant

De assistent die we bouwen accepteert een software-feature request en geeft een gestructureerd plan terug: een technische samenvatting, geordende implementatiestappen, waarschijnlijke bestandswijzigingen, risico’s en tests. 

Ik gebruik dit voorbeeld omdat het de API-details afdwingt die in een echte integratie meestal belangrijk zijn: gestructureerde output, streaming, tool-calls, kosten en afhandeling van weigeringen. Het is klein, maar zeker geen Hello World.

De secties hieronder bouwen die onderdelen stap voor stap.

Feature request stroomt naar gestructureerd plan. Afbeelding door auteur.

De hoofdcode staat in task_assistant.py voor het lokale script en app.py voor het FastAPI-endpoint.

Vereisten

Om mee te doen, heb je nodig:

• Python 3.9 of nieuwer (de tutorial gebruikt 3.10+ features zoals ingebouwde type hints in Pydantic-modellen, maar de SDK zelf ondersteunt 3.9+)

• Een Anthropic API-sleutel met toegang tot claude-fable-5

• Basiskennis van omgevingsvariabelen, JSON en HTTP-API’s

• Een terminal en een code-editor

Het project opzetten

Begin met het maken van een projectmap en een virtuele omgeving.

mkdir task-assistant
cd task-assistant
python -m venv .venv
source .venv/bin/activate   # Windows: .venv\Scripts\activateMogelijk gemaakt door

Installeer de Anthropic SDK, FastAPI en een paar helpers.

pip install anthropic fastapi uvicorn python-dotenv pydanticMogelijk gemaakt door

Maak een .env bestand in de projectroot met je API-sleutel. Commit dit bestand nooit naar versiebeheer.

ANTHROPIC_API_KEY=sk-ant-...Mogelijk gemaakt door

Laad het bovenaan je script. Anthropic() leest ANTHROPIC_API_KEY automatisch uit de omgeving.

from dotenv import load_dotenv
from anthropic import Anthropic

load_dotenv()
client = Anthropic()Mogelijk gemaakt door

Initialiseer de client één keer op module-niveau en hergebruik hem door de hele tutorial.

Je eerste Claude Fable 5 API-call in Python

Voordat ik projectlogica toevoeg, stuur ik graag een minimale request om te bevestigen dat de setup werkt. De Messages API neemt een modelstring, een max_tokens-limiet en een messages-array. max_tokens is verplicht; de SDK gooit een TypeError als je het weglaat.

MODEL = "claude-fable-5"

def get_text(response):
    """Return the first text block, skipping thinking or tool blocks."""
    return next((b.text for b in response.content if b.type == "text"), "")

response = client.messages.create(
    model=MODEL,
    max_tokens=512,
    messages=[{"role": "user", "content": "Reply in one sentence to confirm the API connection is working."}]
)

print(get_text(response))
print(f"Model: {response.model}")
print(f"Input tokens: {response.usage.input_tokens}")
print(f"Output tokens: {response.usage.output_tokens}")Mogelijk gemaakt door

Fable 5 API-antwoord en tokens. Afbeelding door auteur.

response.content is een lijst met contentblokken, geen platte string. Door het hierboven genoemde adaptive thinking is het eerste blok vaak een thinking-blok, en content[0].text kan een AttributeError veroorzaken. De get_text helper filtert daarom op block.type == "text".

Het usage-object geeft je input- en outputtokenaantallen na elke request. response.model meldt welk model antwoordde, wat belangrijk is wanneer fallbacks zijn geconfigureerd.

De diepte van redenering regelen met effort

De effort parameter, doorgegeven binnen output_config, is de schakelaar voor die denkdiepte.

response = client.messages.create(
    model=MODEL,
    max_tokens=2048,
    output_config={"effort": "high"},  # low | medium | high | xhigh | max
    messages=[{"role": "user", "content": feature_request}]
)Mogelijk gemaakt door

De standaard is "high". Ik zou daar beginnen, dan "low" of "medium" gebruiken als latentie zwaarder weegt en "xhigh" of "max" voor langere problemen. Effort verandert hoeveel thinking-tokens het model genereert, niet óf het ze genereert.

Een system prompt toevoegen voor de assistentrol

De system-parameter is een top-level veld in de request, los van de messages -array. Wat je daar zet, geldt voor elke beurt, wat betekent dat het per woord meer doet dan een enkele instructie.

Voor de Developer Task Assistant houd ik de system prompt smal: geef een beknopt engineeringplan in plaats van een brede analyse.

SYSTEM_PROMPT = """You are a senior software engineer who reviews feature requests and returns
implementation plans. For every request:
- Write a one sentence technical summary
- List the implementation steps in order
- Name the files or components most likely to change
- Call out at most three risks or edge cases
- Suggest concrete tests
Do not narrate options you won't pursue. Act on what you know; ask only when key details are missing."""Mogelijk gemaakt door

Die laatste instructie is belangrijk. Fable 5 kan te veel plannen toevoegen voor simpele requests, dus de prompt begrenst de output voordat het antwoord gaat afdwalen.

Geef de system prompt mee bij elke call.

response = client.messages.create(
    model=MODEL,
    max_tokens=2048,
    system=SYSTEM_PROMPT,
    messages=[{"role": "user", "content": feature_request}]
)Mogelijk gemaakt door

Assistant-turn prefilling wordt niet ondersteund op Fable 5. Als je oudere Claude-code hebt die de assistant-beurt start met {"role": "assistant", "content": "{"} om JSON-output af te dwingen, verwijder dat dan. Dat patroon geeft een 400 op Fable 5, wat een gemene valkuil is bij het porten van oudere code.

De feature-planningworkflow bouwen

Een feature plannen betekent architectuur, faalmodi en teststrategie in één antwoord bijhouden. Dit is een goede eerste workflow omdat hij klein genoeg is om te inspecteren, maar niet slechts een speelgoedprompt.

feature = (
    "Add password reset to our Django app. "
    "Users should receive a token via email and land on a form to set a new password."
)

response = client.messages.create(
    model=MODEL,
    max_tokens=2048,
    output_config={"effort": "high"},
    system=SYSTEM_PROMPT,
    messages=[{"role": "user", "content": feature}]
)

print(get_text(response))Mogelijk gemaakt door

Een typisch antwoord behandelt token-generatie, e-mailbezorging, formulierafhandeling en opschonen bij verlopen in één keer.

Gestructureerde JSON-outputs teruggeven met Claude Fable 5

Platte tekst is prima in de terminal. Zodra het plan appdata moet worden, is gestructureerde output makkelijker om mee te werken. De Claude API ondersteunt gestructureerde outputs via client.messages.parse() en een Pydantic-model, en dat werkt met claude-fable-5.

Definieer de verwachte outputvorm als een Pydantic-model.

from pydantic import BaseModel

class FeaturePlan(BaseModel):
    summary: str
    steps: list[str]
    files: list[str]
    risks: list[str]
    tests: list[str]Mogelijk gemaakt door

Geef de klasse door als output_format. De SDK zet het om in een JSON-schema, draait constrained decoding op de servers van Anthropic en geeft een getypt object terug op response.parsed_output.

response = client.messages.parse(
    model=MODEL,
    max_tokens=2048,
    system=SYSTEM_PROMPT,
    messages=[{"role": "user", "content": feature}],
    output_format=FeaturePlan
)

plan = response.parsed_output
if plan is not None:
    print(f"Summary: {plan.summary}")
    print(f"Steps: {plan.steps}")Mogelijk gemaakt door

Controleer parsed_output op None voordat je het gebruikt. Een weigering tijdens streaming of een vroege max_tokens-afkapping kan het leeg achterlaten. Dit pad omzeilt ook het thinking-blokprobleem omdat je parsed_output leest in plaats van in content te graaien.

Als je gestructureerde output nodig hebt op een model zonder API-ondersteuning, vraag dan om JSON in de prompt en valideer die met FeaturePlan.model_validate_json(text), met één retry als het faalt. Combineer gestructureerde output niet met assistant-turn prefilling; Fable 5 geeft daarvoor een 400.

Responses streamen vanuit Claude Fable 5

Datzelfde adaptive thinking kan de wachttijd tot de eerste token verhogen bij complexe prompts. Streaming print tekstchunks zodra ze binnenkomen.

Gebruik de client.messages.stream() contextmanager. stream.text_stream levert tekstchunks en slaat thinking-blokken automatisch over.

with client.messages.stream(
    model=MODEL,
    max_tokens=2048,
    system=SYSTEM_PROMPT,
    messages=[{"role": "user", "content": feature}]
) as stream:
    for chunk in stream.text_stream:
        print(chunk, end="", flush=True)

final = stream.get_final_message()
print(f"\nInput tokens: {final.usage.input_tokens}")
print(f"Output tokens: {final.usage.output_tokens}")Mogelijk gemaakt door

Roep get_final_message() aan nadat het with -blok sluit, niet erin. Daar staan de stopreden en usage-tellingen.

Streaming en gestructureerde output kunnen samen, maar verzamel eerst de volledige response voordat je die parseert. Partiële JSON is geen geldige JSON.

Toolgebruik toevoegen (functieaanroepen)

Met toolgebruik kan het model informatie opvragen in plaats van alleen op de prompt te vertrouwen. Ik houd de eerste tool klein: read_project_file. Het model vraagt om een bestand te lezen, jouw code leest het, en het model gebruikt wat het vindt.

De tool-loop heeft een vaste vorm. Claude retourneert stop_reason: "tool_use" wanneer het een tool wil aanroepen, jij voert de tool uit en stuurt een tool_result-blok terug, en de loop gaat door totdat stop_reason "end_turn" of "refusal" is.

Tool-loop van verzoek tot antwoord. Afbeelding door auteur.

READ_FILE_TOOL = {
    "name": "read_project_file",
    "description": "Read the contents of a file in the project.",
    "input_schema": {
        "type": "object",
        "properties": {
            "path": {"type": "string", "description": "Relative path to the file"}
        },
        "required": ["path"]
    }
}

messages = [{"role": "user", "content": feature}]

while True:
    response = client.messages.create(
        model=MODEL,
        max_tokens=2048,
        system=SYSTEM_PROMPT,
        tools=[READ_FILE_TOOL],
        messages=messages
    )

    if response.stop_reason in ("end_turn", "refusal"):
        break

    if response.stop_reason == "tool_use":
        tool_block = next(b for b in response.content if b.type == "tool_use")

        # Execute the tool locally
        try:
            with open(tool_block.input["path"]) as f:
                result = f.read()[:2000]
        except FileNotFoundError:
            result = f"File not found: {tool_block.input['path']}"

        messages.append({"role": "assistant", "content": response.content})
        messages.append({
            "role": "user",
            "content": [{
                "type": "tool_result",
                "tool_use_id": tool_block.id,
                "content": result
            }]
        })

# Read the final answer
text_block = next((b for b in response.content if b.type == "text"), None)
print(text_block.text if text_block else "No text in final response")Mogelijk gemaakt door

Het model voert deze code nooit uit. Het geeft een gestructureerd verzoek met een toolnaam en JSON-inputs; jouw applicatie voert de bestandslezing uit. Voeg geen conversatietekst toe binnen dezelfde user-beurt als een tool_result-blok, anders kan het model stoppen in plaats van het plan te vervolgen.

Tokengebruik en API-kosten van Claude Fable 5 inschatten

Voordat je dit in een app verandert, check het kostprofiel. Fable 5 kost $10 per miljoen inputtokens en $50 per miljoen outputtokens. Output is meestal de grotere post: een plan van 2.000 tokens kost alleen al $0,10 aan output.

Hier is de prijstabel binnen de Anthropic-familie.

Promptcaching kan de kosten van herhaalde system prompts verlagen. Zodra het system-promptblok gecachet is, kosten herhaalde reads $1 per miljoen tokens in plaats van $10. Het minimale cachebare blok is 512 tokens op de Claude API.

# Count tokens before sending an expensive request
count = client.messages.count_tokens(
    model=MODEL,
    system=SYSTEM_PROMPT,
    messages=[{"role": "user", "content": feature}]
)
print(f"Estimated input tokens: {count.input_tokens}")

# Calculate actual cost after each request
INPUT_PRICE = 10.0 / 1_000_000
OUTPUT_PRICE = 50.0 / 1_000_000

response = client.messages.create(...)
cost = (
    response.usage.input_tokens * INPUT_PRICE +
    response.usage.output_tokens * OUTPUT_PRICE
)
print(f"Total cost: ${cost:.6f}")Mogelijk gemaakt door

count_tokens kost geen geld en telt niet mee tegen je outputratelimiet. Gebruik het om dure requests te bewaken. Voor jobs die geen interactie nodig hebben, halveert de Batch API zowel input- als outputprijzen.

Fable 5 gebruikt de tokenizer die is geïntroduceerd met Opus 4.7, die op dezelfde tekst grofweg 30% meer tokens kan produceren dan oudere Claude-modellen. Houd daar rekening mee bij migraties vanaf Claude 4.6.

Weigeringen en modelfallback afhandelen

Fable 5 draait safety-classifiers naast de generatie. Als er één afgaat, geeft de API een succesvolle HTTP 200 terug, geen error, en het enige signaal is stop_reason: "refusal". Errorhandling die alleen exceptions opvangt, mist weigeringen volledig, en je app retourneert stilletjes niets.

Controleer altijd de stopreden.

response = client.messages.create(
    model=MODEL,
    max_tokens=2048,
    system=SYSTEM_PROMPT,
    messages=[{"role": "user", "content": user_input}]
)

if response.stop_reason == "refusal":
    category = (
        response.stop_details.category
        if response.stop_details else "policy"
    )
    print(f"Request declined ({category}). Please rephrase and try again.")
else:
    print(get_text(response))Mogelijk gemaakt door

In mijn tests wees Fable 5 borderline-verzoeken vaak af in platte tekst, met een normale end_turn. De harde classifierweigering, met stop_reason: "refusal" en lege content, is zeldzamer. De check hierboven dekt dat pad, zodat je app niet stilletjes niets retourneert.

stop_details.category kan zijn "cyber", "bio" of "reasoning_extraction". De laatste treedt op wanneer een prompt probeert de interne chain of thought van het model te extraheren. Voor developer-tools die netwerksecurityscanners of biologische datapijplijnen inspecteren, kun je classifier false positives tegenkomen. Herformuleren om de taak duidelijk defensief te maken, lost het vaak op.

Voor uitgerolde systemen kun je een automatische fallback naar Opus 4.8 configureren met de fallbacks-beta die server-side draait in de Claude API en Claude Platform op AWS. Dat is niet hetzelfde als Amazon Bedrock: Bedrock, Vertex AI en Foundry hebben fallbacklogica in je applicatie nodig.

response = client.beta.messages.create(
    model=MODEL,
    max_tokens=2048,
    system=SYSTEM_PROMPT,
    messages=[{"role": "user", "content": user_input}],
    fallbacks=[{"model": "claude-opus-4-8"}],
    betas=["server-side-fallback-2026-06-01"]
)Mogelijk gemaakt door

Een geweigerde request die geen output genereert, wordt niet gefactureerd. Een weigering halverwege streamen wordt gefactureerd voor wat er vóór het afgaan van de classifier is gegenereerd.

Claude Fable 5 gebruiken met beeld- (vision) inputs

Als je app alleen tekst verwerkt, kun je deze sectie overslaan. Dit deel staat los van de planningflow, maar gebruikt dezelfde Messages API-vorm. Fable 5 accepteert afbeeldingsinputs als base64-gecodeerde blokken of URL’s. Een use case is UI-screenshotreview tegenover een featurerequirement.

import base64

with open("login_form.png", "rb") as f:
    img_data = base64.standard_b64encode(f.read()).decode("utf-8")

response = client.messages.create(
    model=MODEL,
    max_tokens=1024,
    messages=[{
        "role": "user",
        "content": [
            {
                "type": "image",
                "source": {
                    "type": "base64",
                    "media_type": "image/png",
                    "data": img_data
                }
            },
            {
                "type": "text",
                "text": "Review this UI against the requirement: add a 'Forgot password' link below the login button. Is it present? If not, describe what needs to change."
            }
        ]
    }]
)
print(get_text(response))Mogelijk gemaakt door

Een afbeelding op volledige grootte kost grofweg 4.784 inputtokens, ongeacht wat hij toont, dus verklein of comprimeer voor verzending als je geen volledige resolutie nodig hebt. Fable 5 verwerkt afbeeldingen tot 2.576 px breed en schaalt alles groter terug. Ondersteunde formaten zijn JPEG, PNG, GIF en WebP.

De workflow omzetten naar een FastAPI-endpoint

Op dit punt heeft het lokale script de volledige workflow. Wikkel de assistent in een FastAPI-route zodat een frontend of service die kan aanroepen. Gebruik AsyncAnthropic binnen async-routes, omdat de syncclient de eventloop blokkeert. Initialiseer hem één keer bij startup, niet per request.

from contextlib import asynccontextmanager
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from anthropic import AsyncAnthropic

client_instance: AsyncAnthropic | None = None

@asynccontextmanager
async def lifespan(app: FastAPI):
    global client_instance
    client_instance = AsyncAnthropic()
    yield
    await client_instance.close()

app = FastAPI(lifespan=lifespan)

class PlanRequest(BaseModel):
    feature_request: str

@app.post("/plan")
async def create_plan(body: PlanRequest):
    response = await client_instance.messages.create(
        model="claude-fable-5",
        max_tokens=2048,
        system=SYSTEM_PROMPT,
        messages=[{"role": "user", "content": body.feature_request}]
    )

    if response.stop_reason == "refusal":
        raise HTTPException(status_code=400, detail="Request declined by safety classifier.")

    return {
        "plan": get_text(response),
        "input_tokens": response.usage.input_tokens,
        "output_tokens": response.usage.output_tokens
    }Mogelijk gemaakt door

Draai het met uvicorn app:app --reload en test het /plan-endpoint via de FastAPI-docs op http://localhost:8000/docs.