Claude Agent SDK-tutorial: Agents bouwen met Claude Sonnet 4.5

De Claude Agent SDK schetst een gestructureerde agent-lus met vier kernstappen: context verzamelen, actie ondernemen, werk verifiëren en herhalen.

In de praktijk begin je met agentische zoekacties voor context en voeg je semantische search toe wanneer je snelheid nodig hebt. Acties moeten draaien om tools met hoog signaal, bash-scripts en integraties met externe services via het Model Context Protocol. 

Verificatie combineert regelgebaseerde checks, visuele feedback en optionele LLM-assistentie. Voortgezette iteratie wordt aangeraden om prestaties te verfijnen, tools uit te breiden en zoekmogelijkheden te verbeteren naarmate features zich ontwikkelen.

Belangrijkste features:

1. SDK’s: TypeScript en Python voor web-/Node.js-backends en data science, met gedeelde concepten zodat teams patronen kunnen hergebruiken over stacks heen.
2. Modi: Streaming voor interactieve UX met lage latency en single-shot voor batch- of deterministische runs—kies per taak om snelheid en controle te balanceren.
3. Contextbeheer: Automatische compactie en controle over lange sessies om overloop te voorkomen en agents op koers te houden tijdens uitgebreide sessies.
4. Tooling: Ingebouwde bestandsoperaties, code-uitvoering en websearch, plus uitbreidbaarheid voor externe tools en data via MCP.
5. Machtigingen: Fijngranulaire capaciteitscontroles (bijv. per-tool allow/deny en beleidsmodi) om te begrenzen wat een agent in productie mag doen.
6. Productierijp: Ingebouwde foutafhandeling, sessiebeheer en monitoring zodat je vanaf dag één betrouwbare agents met observability kunt uitrollen.
7. Claude-integratie: Automatische promptcaching en prestatie-optimalisaties om latency en kosten te verlagen en throughput te verbeteren.
8. Authenticatie: Gebruik een Claude API-sleutel of routeer via providers als Amazon Bedrock en Google Vertex AI, passend bij je deploymentomgeving.
9. Systeemprompts: Definieer rol, expertise en guardrails om het agentgedrag consistent te sturen over taken en sessies heen.
10. Integraties (MCP): Verbind aangepaste tools, databases en API’s via het open Model Context Protocol, een door Anthropic gesteunde standaard met officiële TypeScript SDK’s en een groeiend ecosysteem.

Aan de slag met Claude Agent SDK in Python

Voordat je projecten gaat bouwen, moet je een paar vereisten instellen, de Claude Code CLI installeren en de Claude Agent SDK installeren.

Vereisten

• Zorg dat je Python versie 3.10 of hoger hebt. 
• Om de Claude Code CLI effectief te gebruiken, moet je ook Node.js versie 18 of hoger en het NPM-pakket installeren.

Claude Code CLI installeren

Voor Windows: 

Open PowerShell en voer de volgende opdracht uit om Claude Code te downloaden en te installeren:

irm https://claude.ai/install.ps1 | iex

Voeg na installatie C:\Users\<user>\.local\bin toe aan het PATH van je systeem. Start PowerShell opnieuw en je zou moeten zien dat Claude draait.

Voor andere platforms:

Als je Node.js en NPM hebt geïnstalleerd, probeer dan de volgende opdracht in de terminal om Claude Code te installeren:

npm i -g @anthropic-ai/claude-code

Volg de instructies om je omgevingsvariabelen in te stellen, zodat je Claude Code kunt gebruiken door simpelweg “claude” in de terminal te typen.

Claude Code instellen

Na het installeren van Claude Code open je het door “claude” in de terminal te typen en in te loggen. Als je een Claude Pro- of Max-abonnement hebt, kies dan “Log in met je abonnementsaccount” zodat het gebruik van je abonnement afkomt.

Als je liever pay-as-you-go gebruikt, authenticeer dan met een API-sleutel; de facturatie loopt via de Anthropic Console. 

Stel tot slot je thema en interface-/CLI-voorkeuren in zodat alles vanaf dag één bij je workflow past.

Ik heb mijn Claude Code ingesteld met de API-sleutel. Je ziet de setup hier:

Claude Agent SDK installeren

Zorg dat Python is geïnstalleerd en open dan je terminal. Om de Claude Agent SDK te installeren, voer je uit:

pip install claude-agent-sdk

Let op: Als je een CLINotFoundError tegenkomt, zorg dan dat je de CLI hierboven hebt geïnstalleerd en dat Claude in je PATH staat.

Projecten bouwen met Claude Agent SDK en Claude Sonnet 4.5

We bouwen nu drie eenvoudige projecten met de Claude Agent SDK als framework, Claude Code voor tools en computergebruik, en Claude Sonnet 4.5 als ons AI-model.

1. One-shot blogoutline: Een eenvoudige one-shot-query die basisgebruik van de Claude Agent SDK zonder tools demonstreert.
2. InspireBot CLI: Dit project combineert webzoekmogelijkheden met een aangepaste fallbacktool voor motiverende quotes.
3. NoteSmith multi-tool app: Een uitgebreide notitie-app met meerdere tools, safety hooks en gebruikstracking.

Alle broncode is beschikbaar in de GitHub-repo: kingabzpro/claude-agent-projects

1. One-shot blogoutline

In dit project gebruiken we de query()-functie van de SDK met Claude Sonnet 4.5 om een blogoutline te maken. Dit is een eenvoudige one-shot-query die basisgebruik van de Claude Agent SDK zonder tools laat zien.

De code bestaat uit: 

1. Async streaming: Gebruikt asyncio met de async iterator van de SDK’s query() voor niet-blokkerende, token-voor-token output.
2. Prompt & opties: Definieert een blogoutline-PROMPT en configureert model/persona via ClaudeAgentOptions.
3. Getypte berichtstroom: Itereert over berichten; extraheert alleen AssistantMessage → TextBlock-inhoud.
4. Realtime output: Print tekst zodra die binnenkomt (end="") voor een schone streamingconsoleweergave.
5. Resultaatafhandeling: Negeert ResultMessage en laat de stream natuurlijk eindigen.
6. Entry point: Voert alles uit met asyncio.run(main()) wanneer een script wordt uitgevoerd.
7. Aanpasbaar & minimaal: Makkelijk om model/prompt te wisselen; lichtgewicht script, ideaal voor demo’s of pipelines.

oneshot_outline.py:

import asyncio
from claude_agent_sdk import (
    query,
    ClaudeAgentOptions,
    AssistantMessage,
    TextBlock,
    ResultMessage,
)

PROMPT = """Create a crisp markdown outline (H2/H3 bullets) for a 500-word blog post:
Title: Why Sovereign AI Compute Matters in 2026
Audience: CTOs and Heads of AI
Tone: pragmatic, non-hype
Include: 3 buyer pains, 3 evaluation criteria, 1 closing CTA
"""

async def main():
    options = ClaudeAgentOptions(
        model="sonnet", 
        system_prompt="You are a precise technical copy strategist."
    )

    async for msg in query(prompt=PROMPT, options=options):
        if isinstance(msg, AssistantMessage):
            for block in msg.content:
                if isinstance(block, TextBlock):
                    print(block.text, end="")  # only the outline
        elif isinstance(msg, ResultMessage):
            pass  # let the iterator end naturally

if __name__ == "__main__":
    asyncio.run(main())

We voeren het script uit en slaan de output dan op als een markdownbestand. 

python oneshot_outline.py > outline.md 

Je kunt het markdownbestand openen en zien dat het correcte technische copy heeft gegenereerd. 

Je kunt terug naar je dashboard op https://console.anthropic.com/usage om je gebruik te controleren. Zoals je ziet gebruikt het model Claude Sonnet 4.5.

2. InspireBot CLI

In dit project bouwen we een terminalvriendelijke motivator die quotes streamt met Claude Sonnet 4.5. Hij probeert eerst een WebSearch en valt daarna terug op een aangepaste inspire_me-tool die willekeurige quotes teruggeeft.

De code bestaat uit:

• Aangepaste fallbacktool: Definieert inspire_me met vooraf ingestelde motiverende quotes, geregistreerd via create_sdk_mcp_server.
• CLI-helpers: is_tty, typewrite, bold, faint voegen een typemachine-animatie en stijlopmaak toe in de terminal.
• Prompt & opties: Geconfigureerd met ClaudeAgentOptions, met tools (WebSearch + inspire_me) en een systeempersona “InspireBot”.
• Streaming tool-calls: Itereert over berichten en toont toolgebruik (ToolUseBlock), resultaten (ToolResultBlock) en uiteindelijke output (TextBlock).
• Fallbacklogica: Als er geen bruikbare output verschijnt, valt hij terug op een willekeurige lokale quote.
• Interactieve UX: Toont streamende tool-inputs/-resultaten en animeert vervolgens de laatste inspirerende regel met typemachine-effect.

inspire_web.py:

import sys
import json
import asyncio
import random
import time
from typing import Any

from claude_agent_sdk import (
    query,
    ClaudeAgentOptions,
    tool,
    create_sdk_mcp_server,
    AssistantMessage,
    TextBlock,
    ToolUseBlock,
    ToolResultBlock,
    ResultMessage,
)

# -------------------------
# Custom fallback tool
# -------------------------
QUOTES = [
    "Dream big, start small -- but start.",
    "Stay curious, stay humble, keep building.",
    "Every expert was once a beginner.",
    "Small wins stack into big victories.",
    "Consistency beats intensity when intensity is inconsistent.",
]

@tool("inspire_me", "Return a random motivational quote", {})
async def inspire_me(_: dict) -> dict:
    return {"content": [{"type": "text", "text": random.choice(QUOTES)}]}

UTILS = create_sdk_mcp_server("inspire_util", "1.0.0", [inspire_me])

# -------------------------
# Tiny terminal helpers
# -------------------------
def is_tty() -> bool:
    try:
        return sys.stdout.isatty()
    except Exception:
        return False

def typewrite(text: str, delay: float = 0.02) -> None:
    """Print with a typewriter effect if TTY; otherwise plain print."""
    if not is_tty():
        print(text)
        return
    for ch in text:
        print(ch, end="", flush=True)
        time.sleep(delay)
    print()

def faint(s: str) -> str:
    """Dim text if terminal supports ANSI."""
    return s if not is_tty() else f"\033[2m{s}\033[0m"

def bold(s: str) -> str:
    return s if not is_tty() else f"\033[1m{s}\033[0m"

# -------------------------
# Main
# -------------------------
async def main():
    topic = "engineering focus" if len(sys.argv) < 2 else " ".join(sys.argv[1:])

    options = ClaudeAgentOptions(
        model="sonnet",  # switch to "sonnet-4.5" if your CLI lists it
        system_prompt=(
            "You are InspireBot.\n"
            "- First, try WebSearch to find a short, uplifting quote relevant to the user's topic.\n"
            "- If WebSearch is unhelpful or no clear quote is found, call the custom 'inspire_me' tool.\n"
            "- Output ONE short line only. No preface, no commentary, <= 120 characters."
        ),
        allowed_tools=[
            "WebSearch",
            "mcp__inspire_util__inspire_me",
        ],
        mcp_servers={"inspire_util": UTILS},
    )

    prompt = (
        "Find a short, uplifting quote for today's inspiration. "
        f"Topic: {topic}. Prefer something crisp and modern.\n"
        "If search yields multiple options, pick the best single line."
    )

    final_line_parts: list[str] = []

    if is_tty():
        print(bold("🌐 InspireBot (WebSearch + fallback tool)"))
        print(faint("Tip: pass a custom topic:  python inspire_web_animated.py \"women in leadership\""))
        print()

    async for message in query(prompt=prompt, options=options):
        # Stream assistant messages for tool usage + final text
        if isinstance(message, AssistantMessage):
            for block in message.content:
                if isinstance(block, ToolUseBlock):
                    tool_name = block.name
                    tool_input = block.input or {}
                    print(f"{bold('🛠️  Tool used:')} {tool_name}")
                    print(f"{faint('   input:')} {json.dumps(tool_input, ensure_ascii=False)}")
                elif isinstance(block, ToolResultBlock):
                    # Show summarized tool result text if present
                    shown = False
                    if isinstance(block.content, list):
                        for part in block.content:
                            if isinstance(part, dict) and part.get("type") == "text":
                                text = (part.get("text") or "").strip()
                                if text:
                                    preview = text if len(text) <= 200 else (text[:197] + "...")
                                    print(f"{faint('   result:')} {preview}")
                                    shown = True
                                    break
                    if not shown:
                        print(f"{faint('   result:')} (no textual content)")
                elif isinstance(block, TextBlock):
                    # This should be the final "inspiration" line content
                    final_line_parts.append(block.text)

        elif isinstance(message, ResultMessage):
            # allow the iterator to finish naturally (no break)
            pass

    final_line = " ".join(part.strip() for part in final_line_parts).strip()
    if not final_line:
        final_line = random.choice(QUOTES)  # ultimate fallback, just in case

    # Animate the final line (typewriter), or plain if not a TTY
    typewrite(final_line, delay=0.02)

if __name__ == "__main__":
    asyncio.run(main())

We voeren het script uit met het standaardonderwerp met de volgende opdracht:  

python inspire_web.py

Zoals we zien toont het de gebruikte tools, de input voor die tools en geeft het vervolgens een motiverende quote.  

Laten we het Python-script een aangepast onderwerp meegeven:  

python inspire_web.py "Sadness and Love"

Dit geeft een motiverende quote terug waarin de keywords "love" en "sadness" voorkomen.

3. NoteSmith multi-tool app

In dit project bouwen we een multi-tool onderzoeksassistent die lokaal notities opslaat en doorzoekt, webpagina’s samenvat en resultaten streamt met Claude Sonnet 4.5. Het combineert aangepaste MCP-tools, ingebouwde tools en een safety hook voor een rijkere CLI-ervaring.

De code bestaat uit:

• Lokale opslag: Slaat notities met tijdstempels op schijf op; ondersteunt hoofdletterongevoelige zoekopdrachten met eenvoudige grep-logica.
• Aangepaste MCP-tools: save_note (tekst opslaan) en find_note (notities doorzoeken), geregistreerd met create_sdk_mcp_server.
• Safety hook: block_dangerous_bash weigert schadelijke shellopdrachten (bijv. rm -rf /) voordat een tool wordt uitgevoerd.
• Systeemprompt & commando’s: Definieert /summarize, /note, /find, /help, /exit; prompt stuurt toolgebruik (WebFetch, save_note, find_note).
• Streaminginteractie: Gebruikt ClaudeSDKClient om AssistantMessage, ToolUseBlock, ToolResultBlock af te handelen, tekst en toolresultaten realtime te printen.
• Gebruikstracking: Print een voettekst met modelnaam, tokens en kosten naar stderr terwijl de hoofdoutput schoon blijft.
• Chatinterface: Werkt als een lichte REPL waar je commando’s typt (/note, /find, /summarize) en direct antwoord krijgt, waardoor het voelt alsof je met een assistent chat.

note_smith.py:

import sys
import json
import asyncio
from datetime import datetime
from pathlib import Path
from typing import Any

from claude_agent_sdk import (
    ClaudeSDKClient,
    ClaudeAgentOptions,
    AssistantMessage,
    TextBlock,
    ToolUseBlock,
    ToolResultBlock,
    ResultMessage,
    tool,
    create_sdk_mcp_server,
    HookMatcher,
    HookContext,
)

# ----------------------------
# Storage (simple local notes)
# ----------------------------

NOTES_DIR = Path(__file__).parent / "notes"
NOTES_DIR.mkdir(exist_ok=True)

def _ts() -> str:
    return datetime.now().strftime("%Y-%m-%d_%H-%M-%S")

def save_note_to_disk(text: str) -> str:
    path = NOTES_DIR / f"note_{_ts()}.txt"
    path.write_text(text.strip() + "\n", encoding="utf-8")
    return str(path)

def grep_notes(pattern: str) -> list[str]:
    pat = pattern.lower()
    out: list[str] = []
    for p in NOTES_DIR.glob("*.txt"):
        for i, line in enumerate(p.read_text(encoding="utf-8").splitlines(), start=1):
            if pat in line.lower():
                out.append(f"{p.name}:{i}: {line}")
    return out

# ----------------------------
# Custom MCP tools
# ----------------------------

@tool("save_note", "Save a short note to local disk", {"text": str})
async def save_note(args: dict[str, Any]) -> dict[str, Any]:
    path = save_note_to_disk(args["text"])
    return {"content": [{"type": "text", "text": f"Saved note → {path}"}]}

@tool("find_note", "Find notes containing a pattern (case-insensitive)", {"pattern": str})
async def find_note(args: dict[str, Any]) -> dict[str, Any]:
    hits = grep_notes(args["pattern"])
    body = "\n".join(hits) if hits else "No matches."
    return {"content": [{"type": "text", "text": body}]}

UTILS_SERVER = create_sdk_mcp_server(
    name="notes_util",
    version="1.0.0",
    tools=[save_note, find_note],
)

# ----------------------------
# Optional safety hook (Bash)
# ----------------------------

async def block_dangerous_bash(
    input_data: dict[str, Any],
    tool_use_id: str | None,
    context: HookContext
):
    if input_data.get("tool_name") == "Bash":
        cmd = str(input_data.get("tool_input", {}).get("command", "")).strip().lower()
        if "rm -rf /" in cmd or "format c:" in cmd:
            return {
                "hookSpecificOutput": {
                    "hookEventName": "PreToolUse",
                    "permissionDecision": "deny",
                    "permissionDecisionReason": "Dangerous command blocked"
                }
            }
    return {}

# ----------------------------
# Prompts & UI
# ----------------------------

SYSTEM_PROMPT = """You are NoteSmith, a concise research assistant.
- Prefer bullet answers with crisp takeaways.
- When the user asks to /summarize <url>, use WebFetch to retrieve and then summarize 5 key points + a 1-line TL;DR.
- When the user types /note <text>, call the custom save_note tool.
- When the user types /find <pattern>, call the custom find_note tool.
- Keep answers short unless asked to expand.
"""

HELP = """Commands:
  /summarize <url>      Summarize a webpage (WebFetch)
  /note <text>          Save a note locally
  /find <pattern>       Search saved notes
  /help                 Show this help
  /exit                 Quit
"""

# Use the broadest model label for compatibility; switch to "sonnet-4.5" if your CLI lists it.
MODEL = "sonnet"

# ----------------------------
# Main app
# ----------------------------

async def main():
    options = ClaudeAgentOptions(
        model=MODEL,
        system_prompt=SYSTEM_PROMPT,
        permission_mode="acceptEdits",
        allowed_tools=[
            # Built-ins (Claude may use these if relevant)
            "WebFetch", "Read", "Write", "Grep", "Glob",
            # Our MCP tools (SDK prefixes mcp__<alias>__<toolname>)
            "mcp__utils__save_note",
            "mcp__utils__find_note",
        ],
        mcp_servers={"utils": UTILS_SERVER},
        hooks={"PreToolUse": [HookMatcher(hooks=[block_dangerous_bash])]},
        setting_sources=None,  # no filesystem settings; everything is programmatic
    )

    print("💡 NoteSmith (Claude Sonnet)\n")
    print(HELP)

    async with ClaudeSDKClient(options=options) as client:
        while True:
            user = input("\nYou: ").strip()
            if not user:
                continue
            if user.lower() in {"/exit", "exit", "quit"}:
                print("Bye!")
                break
            if user.lower() in {"/help", "help"}:
                print(HELP)
                continue

            # Lightweight command parsing (the system prompt also guides tool usage)
            if user.startswith("/summarize "):
                url = user.split(" ", 1)[1].strip()
                prompt = f"Summarize this URL using WebFetch and return 5 bullets + TL;DR:\n{url}"
            elif user.startswith("/note "):
                text = user.split(" ", 1)[1]
                prompt = f'Please call tool save_note with text="{text}"'
            elif user.startswith("/find "):
                patt = user.split(" ", 1)[1]
                prompt = f'Please call tool find_note with pattern="{patt}"'
            else:
                prompt = user

            await client.query(prompt)

            # -------- Response streaming with footer to STDERR --------
            model_used = None
            usage = None
            cost = None

            async for message in client.receive_response():
                if isinstance(message, AssistantMessage):
                    if model_used is None:
                        model_used = message.model  # e.g., "sonnet" or "sonnet-4.5"
                    for block in message.content:
                        if isinstance(block, TextBlock):
                            print(block.text, end="", flush=True)  # stdout
                        elif isinstance(block, ToolUseBlock):
                            print(f"\n🛠️  Using tool: {block.name} with input: {json.dumps(block.input)}")
                        elif isinstance(block, ToolResultBlock):
                            if isinstance(block.content, list):
                                for part in block.content:
                                    if isinstance(part, dict) and part.get("type") == "text":
                                        print(f"\n🔎 Tool says: {part.get('text')}")
                elif isinstance(message, ResultMessage):
                    usage = message.usage or {}
                    cost = message.total_cost_usd
                    # Do not break early; let stream end naturally

            # Footer (model + tokens + cost) → STDERR so normal output stays clean
            def _token_summary(u: dict) -> str:
                total = u.get("total_tokens")
                if total is None:
                    it, ot = u.get("input_tokens"), u.get("output_tokens")
                    if it is not None or ot is not None:
                        total = (it or 0) + (ot or 0)
                if total is None:
                    return "tokens=?"
                if "input_tokens" in u or "output_tokens" in u:
                    return f"tokens={total} (in={u.get('input_tokens','?')}, out={u.get('output_tokens','?')})"
                return f"tokens={total}"

            footer = (
                f"\n\n-- Turn done. model={(model_used or options.model)} "
                f"{_token_summary(usage or {})} cost={cost if cost is not None else '?'} --"
            )
            print(footer, file=sys.stderr)

# Entry
if __name__ == "__main__":
    asyncio.run(main())

Om de app te starten, typ je de volgende opdracht in de terminal:

python note_smith.py

Dit start de CLI-chatinterface met handige commando’s.

We vatten eerst de webpagina samen. Ik heb de URL van mijn portfolio-website opgegeven:

/summarize abid.work

Eerst bepaalt de agent welke tools te gebruiken, haalt de content op van de webpagina, haalt vijf kernpunten eruit en toont die in de chatinterface. Aan het eind verschijnt een gebruiksrapport met de modelnaam, tokengebruik en kosten.

I'll fetch and summarize the content from that URL for you.                                    
🛠️  Using tool: WebFetch with input: {"url": "https://abid.work", "prompt": "Extract the main content and key information from this page, including what the person does, their background, projects, and any notable achievements or areas of focus."}


**5 Key Points:**

• **Prolific Tech Educator** - Authored 500+ articles making data science & ML accessible through tutorials, cheat sheets, and practical guides

• **Certified Data Scientist** - Professional focus on building innovative machine learning solutions across NLP, computer vision, and MLOps

• **Multi-Domain Expertise** - Covers Python, SQL, AI, and end-to-end ML workflows with hands-on project demonstrations

• **Content-First Philosophy** - Maintains extensive portfolio including blogs, tutorials, book reviews, and career resources

• **Open Contributor** - Active on GitHub (kingabzpro) sharing code and projects with the community

**TL;DR:** Abid Ali Awan is a certified data scientist who's authored 500+ educational articles and tutorials, specializing in ML, NLP, and making complex tech concepts accessible to learners.

-- Turn done. model=claude-sonnet-4-5-20250929 tokens=326 (in=6, out=320) cost=0.062402849999999996 --

Vervolgens slaan we een notitie op:

/note what is love

We hebben de instructie gegeven om de notitie met de tekst “what is love” op te slaan.

🛠️  Using tool: mcp__utils__save_note with input: {"text": "what is love"}


✓ Note saved: "what is love"

-- Turn done. model=claude-sonnet-4-5-20250929 tokens=81 (in=6, out=75) cost=0.07421549999999999 --

Tot slot zoeken we de notitie op door een keyword uit de notitie op te geven:

/find love

Zoals je ziet heeft hij het bestand gevonden en de tekst eruit getoond.

🛠️  Using tool: mcp__utils__find_note with input: {"pattern": "love"}


**Found 1 note matching "love":**

• `note_2025-09-30_17-18-02.txt` - "what is love"

-- Turn done. model=claude-sonnet-4-5-20250929 tokens=105 (in=6, out=99) cost=0.08423339999999999 --

Conclusie 

De Claude Agent SDK is eenvoudig in te richten, zeker als je Claude Code al lokaal hebt geïnstalleerd. Het enige wat nodig is, is het SDK-pakket installeren. 

De Python-SDK biedt twee hoofdmanieren om met Claude te werken:

• query() – een eenvoudige tekstgeneratie-API die het best is voor lichte use-cases, al ondersteunt die geen tools.
• ClaudeSDKClient – een volledig uitgeruste agentische API waarmee je sessies kunt hervatten, tools kunt gebruiken, handmatige controle behoudt en meer.

In deze tutorial verkenden we het nieuwste model van Anthropic, Claude Sonnet 4.5, en introduceerden we de nieuwe Claude Agent SDK. We doorliepen het installatieproces en bouwden drie voorbeeldprojecten om de mogelijkheden te demonstreren.

Als je geïnteresseerd bent om met agentische workflows te experimenteren, raad ik je zeker aan om deze SDK te proberen.