Como usar o SDK do Claude Agent com o Claude Sonnet 4.5

O SDK do Claude Agent descreve um ciclo estruturado do agente envolvendo quatro etapas principais: coleta de contexto, tomada de ação, verificar o trabalhoe repetir.

Na prática, comece com a pesquisa agênica para contexto e adicione a pesquisa semântica quando precisar de velocidade. As ações devem se concentrar em ferramentas de alto sinal, scripts bash e integrações com serviços externos por meio do Protocolo de Contexto do Modelo. 

A verificação junta verificações baseadas em regras, feedback visual e assistência LLM opcional. Recomenda-se a iteração contínua para refinar o desempenho, expandir as ferramentas e aprimorar os recursos de pesquisa à medida que os recursos são desenvolvidos.

Principais características:

1. SDKs: TypeScript e Python para backends web/Node.js e ciência de dados, com conceitos compartilhados para que as equipes possam reutilizar padrões em todas as pilhas.
2. Modos: Streaming para uma experiência do usuário interativa e de baixa latência e execução única para execuções em lote ou determinísticas — escolha por tarefa para equilibrar velocidade e controle.
3. Gerenciamento de contexto: Compactação automática e controle de contexto de longo prazo para evitar sobrecarga e manter os agentes no programa durante sessões prolongadas.
4. Ferramentas: Operações de arquivo integradas, execução de código e pesquisa na web, além de extensibilidade para ferramentas externas e dados via MCP.
5. Permissões: Controles de capacidade detalhados (por exemplo, permissões/proibições por ferramenta e modos de política) para limitar o que um agente pode fazer na produção.
6. Pronto para produção: Gerenciamento de erros, gerenciamento de sessões e monitoramento integrados para que você possa implantar agentes confiáveis com observabilidade desde o primeiro dia.
7. Integração com Claude: Cache automático de prompts e otimizações de desempenho pra reduzir a latência e os custos, melhorando a taxa de transferência.
8. Autenticação: Use uma chave API Claude ou faça o roteamento por meio de provedores como Amazon Bedrock e Google Vertex AI para se adequar ao seu ambiente de implantação.
9. Mensagens do sistema: Defina a função, a especialização e as diretrizes para moldar o comportamento do agente de forma consistente em todas as tarefas e sessões.
10. Integrações (MCP): Conecte ferramentas personalizadas, bancos de dados e APIs através do Protocolo de Contexto de Modelo aberto, um padrão apoiado pela Anthropic com SDKs TypeScript oficiais e um ecossistema em crescimento.

Introdução ao SDK do Claude Agent em Python

Antes de começar a criar projetos, você precisa definir alguns pré-requisitos, instalar o Claude Code CLI e o Claude Agent SDK.

Pré-requisitos

• Certifique-se de que você tem a versão 3.10 ou superior do Python. 
• Pra usar o Claude Code CLI de forma eficaz, você também precisa instalar o Node.js versão 18 ou superior e o pacote NPM.

Instalar o Claude Code CLI

Para Windows: 

Abra o PowerShell e execute o seguinte comando para baixar e instalar o Claude Code:

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

Depois de instalar, adicione C:\Users\\.local\bin ao PATH do seu sistema. Reinicie o PowerShell e você verá que o Claude está em execução.

Para outras plataformas:

Se você já tem o Node.js e o NPM instalados, tente executar o seguinte comando no terminal para instalar o Claude Code:

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

Siga as instruções para configurar suas variáveis de ambiente para que você possa acessar o Claude Code simplesmente digitando “claude” no terminal.

Configurando o Claude Code

Depois de instalar o Claude Code, abra-o digitando “claude” no terminal e faça login. Se você tem um plano Claude Pro ou Max, escolha “Fazer login com sua conta de assinatura” para que o uso seja contabilizado no seu plano.

Se você preferir o modelo pré-pago, autentique-se com uma chave API; o faturamento será feito pelo Anthropic Console. 

Por fim, defina suas preferências de tema e interface/CLI para que tudo se adapte ao seu fluxo de trabalho desde o primeiro dia.

Eu configurei meu Claude Code com a chave API. Você pode ver a configuração aqui:

Instalar o SDK do Claude Agent

Certifique-se de que o Python está instalado e, em seguida, abra o seu terminal. Para instalar o SDK do Claude Agent, execute:

pip install claude-agent-sdk

Observação: Se você encontrar um CLINotFoundError, certifique-se de ter instalado a CLI acima e que o Claude esteja incluído no seu PATH.

Criando projetos com o SDK do Claude Agent e o Claude Sonnet 4.5

Agora vamos criar três projetos simples usando o SDK do Claude Agent como estrutura, o código Claude para ferramentas e uso do computador e o Claude Sonnet 4.5 como nosso modelo de IA.

1. Esboço do blog One-shot: Uma consulta simples e única que mostra como usar o SDK do Claude Agent sem precisar de ferramentas.
2. InspireBot CLI: Esse projeto junta recursos de busca na web com uma ferramenta personalizada de citações motivacionais.
3. Aplicativo NoteSmith Multi-Tool: Um aplicativo de notas completo com várias ferramentas, ganchos de segurança e acompanhamento de uso.

Todo o código-fonte está disponível no repositório GitHub: kingabzpro/claude-agent-projects

1. Esboço de blog único

Neste projeto, usamos a função query() do SDK com o Claude Sonnet 4.5 para criar um esboço de blog. Essa é uma consulta simples e única que mostra como usar o SDK básico do Claude Agent sem precisar de ferramentas.

O código é composto por: 

1. Streaming assíncrono: Usa asyncio com o iterador assíncronoquery() do SDK para uma saída sem bloqueio, token por token.
2. Prompt e opções: Define um esboço do blog PROMPT e configura o modelo/persona através de ClaudeAgentOptions.
3. Fluxo de mensagens digitadas: Repete as mensagens; pega só o conteúdo AssistantMessage → TextBlock.
4. Saída em tempo real: Imprime o texto conforme ele chega (end="") para uma visualização limpa do console de streaming.
5. Tratamento dos resultados: Ignora o ` ResultMessage`, deixando o fluxo terminar naturalmente.
6. Ponto de entrada: Executa tudo com um asyncio.run(main()) e quando um script é executado.
7. Personalizável e minimalista: Fácil de trocar modelo/prompt; script leve, ideal para demonstrações ou 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())

Vamos rodar o script e depois salvar o resultado como um arquivo markdown. 

python oneshot_outline.py > outline.md 

Você pode abrir o arquivo markdown e ver que ele gerou uma cópia técnica adequada. 

Você pode voltar ao seu painel em https://console.anthropic.com/usage para conferir o seu uso. Como você pode ver, o modelo está usando o Claude Sonnet 4.5.

2. CLI do InspireBot

Neste projeto, criamos um gerador de motivação fácil de usar no terminal que transmite citações usando o Claude Sonnet 4.5. Primeiro, ele tenta uma pesquisa na Web e, em seguida, recorre a uma ferramenta personalizada inspire_me que retorna citações aleatórias.

O código é composto por:

• Ferramenta de fallback personalizada: Define inspire_me com citações motivacionais pré-definidas, registradas através de create_sdk_mcp_server.
• Ajudantes da CLI: is_tty, typewrite, bold, faint adicionam animação de máquina de escrever e saída estilizada no terminal.
• Prompt e opções: Configurado com ClaudeAgentOptions, permitindo ferramentas (WebSearch + inspire_me) e uma persona do sistema “InspireBot”.
• A ferramenta de streaming chama: Repete as mensagens, mostrando o uso da ferramenta (ToolUseBlock), os resultados (ToolResultBlock) e a saída final (TextBlock).
• Lógica de fallback: Se não aparecer nada que possa ser usado, ele vai mostrar uma citação local aleatória.
• UX interativo: Mostra as entradas/resultados da ferramenta de streaming e, em seguida, anima a frase inspiradora final com efeito de máquina de escrever.

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())

Vamos rodar o script com o tópico padrão usando o seguinte comando:  

python inspire_web.py

Como dá pra ver, ele mostra as ferramentas usadas, o que foi colocado nessas ferramentas e, depois, mostra uma frase motivacional.  

Vamos dar ao script Python um tópico personalizado:  

python inspire_web.py "Sadness and Love"

Isso mostra uma frase motivacional que inclui as palavras-chave “amor” e “tristeza”.

3. Aplicativo multifuncional NoteSmith

Neste projeto, criamos um assistente de pesquisa multifuncional que salva e pesquisa notas localmente, resume páginas da web e transmite os resultados com o Claude Sonnet 4.5. Ele junta ferramentas MCP personalizadas, ferramentas integradas e um gancho de segurança para uma experiência CLI mais rica.

O código é composto por:

• Armazenamento local: Salva notas no disco com carimbos de data/hora; suporta pesquisa sem distinção entre maiúsculas e minúsculas usando lógica grep simples.
• Ferramentas MCP personalizadas: save_note (armazenar texto) e find_note (notas de pesquisa), registradas com create_sdk_mcp_server.
• Gancho de segurança: block_dangerous_bash impede comandos shell maliciosos (por exemplo, rm -rf /) antes de executar a ferramenta.
• Prompt do sistema e comandos: Define /summarize, /note ,/find, /help ,/exit; prompt orienta o uso da ferramenta (WebFetch, save_note, find_note).
• Interação de streaming: Usa ClaudeSDKClient para lidar com AssistantMessage, ToolUseBlock, ToolResultBlock, imprimindo texto e resultados de ferramentas em tempo real.
• Rastreamento de uso: Imprime um rodapé com o nome do modelo, tokens e custo em stderr, mantendo a saída principal limpa.
• Interface de chat: Funciona como um REPL leve, onde você digita comandos (/note, /find, /summarize) e recebe respostas imediatas, dando a sensação de estar conversando com um assistente.

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())

Para rodar o aplicativo, digite o seguinte comando no terminal:

python note_smith.py

Isso vai abrir a interface de bate-papo da CLI com comandos úteis.

Primeiro, vamos resumir a página da web. Eu já mandei o link do meu site de portfólio:

/resumir trabalho abid.

Primeiro, o agente vai decidir quais ferramentas usar, pegar o conteúdo da página da web, extrair cinco pontos principais e mostrá-los na interface de chat. No final, vai aparecer um relatório de uso que inclui o nome do modelo, o uso de tokens e o custo.

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 --

Agora, vamos salvar uma nota:

/nota o que é o amor

Pedimos pra ele salvar a nota com o texto “o que é amor”.

🛠️  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 --

Por fim, vamos encontrar a nota fornecendo uma palavra-chave da nota:

/encontrar o amor

Como você pode ver, ele encontrou o arquivo e mostrou o texto dele.

🛠️  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 --

Conclusão 

O SDK do Claude Agent é fácil de configurar, principalmente se você já tiver o Claude Code instalado no seu computador. Tudo o que você precisa fazer é instalar o pacote SDK. 

O SDK Python oferece duas maneiras principais de interagir com o Claude:

• query() – uma API simples de geração de texto que é ideal para casos de uso leves, embora não ofereça suporte a ferramentas.
• ClaudeSDKClient – uma API com todos os recursos que te permite retomar sessões, usar ferramentas, manter o controle manual e muito mais.

Neste tutorial, a gente explorou o mais recente modelo da Anthropic, o Claude Sonnet 4.5, e apresentou o novo SDK do Claude Agent. A gente deu uma olhada no processo de instalação e criou três projetos de exemplo pra mostrar o que ele pode fazer.

Se você estiver interessado em experimentar fluxos de trabalho com agentes, recomendo muito que experimente este SDK.