The AI Toolchain — issue 014, September 2, 2026

Adds ingest_har command that accepts a HAR file captured during an authenticated session, registers its session credentials (Authorization, Cookie, and API-key headers) for use by subsequent http_request and authz_matrix calls, and seeds the ledger with the HAR's authenticated endpoints as role=authenticated authorization hypotheses. Introduces an internal/har parser that extracts exercised endpoints (skipping static assets), their query and body parameters, and session headers, with host-scope filtering.

$ xalgorix ingest_har captured_session.har

Adds optional hypothesis_id parameter to report_vulnerability: on a successful report, attaches the finding as finding_ref evidence to the named ledger hypothesis and marks it proven, eliminating a separate add_hypothesis_evidence call. Empty or unknown hypothesis_id values are silently ignored.

Introduces authz_matrix, a multi-role authorization matrix for deep-testing authorization logic where autonomous scanners are weakest. Extended with a role=b parameter to ingest_har for registering a second account as role B, enabling true two-account IDOR/BOLA testing where authz_matrix replays each request as role A, role B, and anonymous to flag cross-account object access.

$ ingest_har path=second_user.har role=b

Uploaded scan-context artifacts (OpenAPI/Swagger specs, HAR files, Postman collections, Burp exports) now seed the shared hypothesis ledger as bounded, role-scoped IDOR/BOLA authorization hypotheses, directly driving authz_matrix and evidence-driven specialists rather than serving as a passive text briefing. Role assignment is automatic: authenticated when the artifact carried a live session, anonymous otherwise. Seeding is deduplicated by class, endpoint, parameter, and role, preventing scheduler flooding or double-counting across sub-agents — mirroring what ingest_har does mid-scan, now applied to every context upload at scan start.

Adds verify_oob, a ledger-integrated out-of-band (OAST) verification capability that polls a planted interactsh token to confirm blind vulnerabilities (blind SQLi, RCE, CMDi, XXE, SSRF) and records blind-execution proof in the shared ledger. Applies class-aware verdicts: SSRF requires an assessed non-scanner HTTP interaction, while blind RCE/CMDi/XXE/SQLi are confirmed by any genuine non-scanner callback (HTTP or DNS).

Introduces verify_xss, a browser-backed XSS execution verification tool for confirming exploitability beyond static detection, initially via JS dialogs. Extended to confirm XSS execution via console.* API calls and DOM markers (document.title / window.name), covering non-dialog and DOM-only sinks.

Adds support for test_thread_id and session_id parameters on the /runs/rules/validate endpoint, letting users test multi-turn thread evaluators against a real conversation before saving them.

$ curl -X POST 'https://<your-langsmith-host>/runs/rules/validate' \
  -H 'Content-Type: application/json' \
  -H 'X-Api-Key: <your-api-key>' \
  -d '{"test_thread_id": "<thread-uuid>", "session_id": "<session-uuid>"}'

Bulk export compression now defaults to zstandard (zstd) for improved performance; self-hosted environments retain the gzip default via the FF_BULK_EXPORT_DEFAULT_COMPRESSION environment variable.

The batched-run ingestion log now emits run_verbs as a list of run_id and verbs objects instead of a map keyed by run UUID, preventing structured-log aggregators from exhausting dynamic field limits.

Code evaluator upload now accepts Python entrypoints annotated with PEP 604 union return types (for example -> dict | None).

Adds a GET /v1/attention endpoint that classifies every visible task before limiting rows, returning a truthful complete count of failed checks, failed steps, and blockers without fetching each receipt individually.

$ curl http://127.0.0.1:8765/v1/attention

Decision signals now keep confirmed active work, provider capacity, ingestion health, and completed-period usage change as separate facts; missing, stale, malformed, future-dated, negative, non-finite, or overflowing values render as 'unavailable' instead of a confident number. A failed or missing attention refresh can no longer read as 'all clear'.

PXI can now file GitHub issues from surfaced defects: it searches for duplicates and opens an issue linking the relevant traces and spans, powered by GitHub's hosted MCP server, with an approval step showing the exact repository, title, and body before posting. Configuration surfaces include PHOENIX_AGENTS_DISABLE_GITHUB=true to disable the GitHub tools and hide the settings UI, PHOENIX_AGENTS_GITHUB_MCP_URL to override the MCP server base URL (default https://api.githubcopilot.com/mcp/) for self-hosted github-mcp-server deployments, GITHUB_PERSONAL_ACCESS_TOKEN as a server-side fallback token, and a githubPersonalAccessToken key in ~/.px/settings.json for terminal profiles; admins manage a shared workspace token or disable the tools under Settings → Assistant → System settings → GitHub tools, and users set personal tokens under Settings → Assistant → Personal settings → GitHub.

$ export PHOENIX_AGENTS_GITHUB_MCP_URL=https://github.example.corp/mcp/

{
  "githubPersonalAccessToken": "github_pat_XXXX"
}

$ export PHOENIX_AGENTS_DISABLE_GITHUB=true

Exposes cumulative prompt, completion, and total token count fields on the high-level Session objects returned by getSession and listSessions.

Gates execute_browser_action scripts in PXI behind whole-script approval, adding an explicit human-in-the-loop safety check before browser automation runs.

Adds eval instrumentation for Agno via auto_instrument() in the Python SDK (v0.36.0): AccuracyEval, AgentAsJudgeEval, ReliabilityEval, and PerformanceEval are now traced automatically, and eval suite runs open a Braintrust experiment automatically.

from braintrust import auto_instrument
from agno.evals import AccuracyEval, ReliabilityEval

auto_instrument()

suite = [AccuracyEval(...), ReliabilityEval(...)]
for ev in suite:
    ev.run()

Introduces the All AI Provider Access built-in permission group, auto-populated with existing members and service accounts, granting use access to every organization AI provider. Adds organization-level AI provider permissions (Pro/Enterprise) via Permission groups controlling view/use, configure, delete, and manage access across playgrounds, experiments, scorers, and the Gateway. Adds per-provider permission controls (Enterprise only) via each provider's Provider permissions icon, with Use, Edit, Delete, and Manage access grants assignable to groups, members, or service accounts. Adds project-level AI provider permissions where the Project viewer permission enables use of all project providers, with a separate permission controlling adding, editing, and deleting project-level providers.

Adds report_scores and report_metrics inputs to the GitHub eval action (v2.1.0) to filter which scores and metrics appear in the PR comment; each accepts a comma- or newline-separated list of names, and omitting either input includes all results in that category. The PR comment table now labels scores and metrics in separate sections within a single table.

Adds Dashboards to the Observe section for browsing, filtering, grouping, and drilling into aggregated metrics across logs and experiments over time. Supports dashboard management — cloning the built-in dashboard, starting empty, duplicating an existing one, and copying dashboards between projects. Adds chart types (time series, top list, big number) with export, duplicate, and move-between-dashboards actions, plus per-trace averages via custom measures (e.g. average cost and LLM calls per trace). Also adds API support for creating blank dashboards programmatically.

Adds a LangChain4j tracing integration to trace LangChain4j calls for prompt debugging, model evaluation, and production monitoring. Adds a DeepSeek Harness agent framework integration tracing agent sessions including user turns, LLM steps, tool calls, and child session interactions. Adds an OpenCode integration via the trace-opencode plugin giving access to Braintrust data through built-in tools or MCP. Adds pi coding session tracing via the pi-extension package, capturing turns, model calls, tool executions, and compactions.

Adds standard verifier output upload to the Harbor plugin — test-stdout.txt, test-stderr.txt, and ctrf.json — with support for attachments and redact_patterns configuration.

Adds gateway token budget policies scoped to a project, user, or API key to cap spend and token usage on every gateway request, documented under gateway-token-budgets.

Groq added openai/gpt-oss-20b and openai/gpt-oss-120b, both accessible via https://api.groq.com/openai/v1/chat/completions. Both are MoE reasoning models with a 131K context window, 32K max output tokens, built-in browser search and code execution, and structured output support; the 20B model runs at ~1000+ TPS while the 120B model runs at ~500+ TPS.

$ curl https://api.groq.com/openai/v1/chat/completions \
  -H "Authorization: Bearer $GROQ_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "openai/gpt-oss-20b", "messages": [{"role": "user", "content": "Explain why fast inference is critical for reasoning models"}]}'

Every runner and bridge binary now ships with signed checksum attestations and SLSA provenance for pre-install verification; every Docker image CI builds or ships is pinned; and both installers now fail closed on a tampered download checksum.

Rejects dispatches that fail to decode or carry the wrong wire-protocol version at the wire, journaling the event; protocol mismatches are now permanent rather than retried.

Runs each pack contained to its own directory tree; the runner refuses a credential file it does not own or that is reached through a symlink.

Adds a one-time audit CSV export bounded by size, replacing an unbounded export that could mis-signal a drained queue.

Adds redaction of secret-bearing reads at the source, covering Redis ACLs, pm2 environments, and secret-named variants.

Adds find_actions pagination by rank in the MCP bridge, so promoting a concept no longer loops or skips results.

Ships privileged packs with an exact host-access recipe and disables the user curlrc for every pack's curl invocations.

Adds SIGHUP support to reload the full runner config without a process restart.

Adds accounts/fireworks/routers/glm-5p2-fast as a new serverless serving path, enabling routing to the GLM-5P2 fast model via the Fireworks AI inference API (POST https://api.fireworks.ai/inference/v1/chat/completions with model set to this path).

$ curl -X POST https://api.fireworks.ai/inference/v1/chat/completions \
  -H 'Authorization: Bearer <your_api_key>' \
  -H 'Content-Type: application/json' \
  -d '{"model": "accounts/fireworks/routers/glm-5p2-fast", "messages": [{"role": "user", "content": "Hello"}]}'

Serverless adaptive rate limit ceilings now vary by model size tier: higher ceilings for models under 400B parameters, intermediate ceilings for 400B–1.6T, and previous base ceilings for models at or above 1.6T.

A new SessionImportService discovers and imports conversation history from Claude Code (~/.claude/projects), Codex (~/.codex/sessions), and opencode (opencode.db), translating each into Cline's native message format as fully resumable sessions, with transactional, per-source idempotent imports. The desktop app exposes this via an 'Import' button in the Sessions header and a row in Settings → General, with per-tool grouping, select-all, search by title/folder/first prompt, and already-imported state tracking.

Adds ten new providers to the built-in model catalog: Bothub, OpenReason, SenseNova (China), TokenGo, TokenRouter, Vancine, Volcengine Ark, Volcengine Ark Coding Plan, above.dev, and klokintegration.se (desktop's release included eight of these). Cline provider models are now fetched from the live catalog rather than only the bundled one, so newly published models appear without an extension or package update, while explicit runtime and models.json overrides still take precedence; model lists and pricing were updated across providers.

Scheduled agent runs now collapse into a single collapsible sidebar row named after the schedule, showing run count and listing individual runs newest-first as 'Run N' with a status dot, time, hover card, context menu, and delete. Underlying this, scheduled sessions now carry their schedule's identity — id, name, cron run id, and a stable 1-based run number — so clients can group runs under the schedule that produced them.

The resolved default model changes for 57 providers on upgrade for anyone who has not pinned a model; most consequentially Anthropic now resolves to Claude Fable 5.1 instead of Claude Opus 5, with Amazon Bedrock, Vertex, OpenRouter, Vercel AI Gateway, Kilo Gateway, LLM Gateway, DevPass, DigitalOcean, CrossModel, Eden AI, and NanoGPT also changing defaults.

Agent-created schedules now persist to ~/.cline/schedules instead of the chat folder where they were created, giving them a stable home across hub restarts and making them visible to workspace-scoped listings and durable across folder cleanup; schedules created with --workspace are unaffected. Token-authenticated hub connections can now request cross-workspace schedule access to list schedules living outside the registered workspace, while workspace-bound clients remain scoped.

When the running Hub is older than the app or CLI, Cline now prompts to replace it — showing the number of active sessions a replacement would interrupt — or keep it running; choosing replace drains in-flight turns before swapping, instead of silently talking to stale code (CLI offers enter-to-replace, escape-to-keep).

Global rules are now also read from ~/Cline/Rules, which is the path the VS Code Rules tab writes to on WSL and headless installs, unifying rule pickup across environments.

Codex CLI now detects Vite+-managed installs via the CODEX_MANAGED_BY_VITE_PLUS environment variable, and this is reported in codex doctor output alongside npm, bun, and pnpm.

Kiro now exports per-user usage metrics (adoption, engagement, credit consumption by user and model) to OpenTelemetry-compatible platforms via OTLP/gRPC or HTTP/protobuf, delivered server-side daily at 02:00 UTC. It is configured at the account level through the Kiro console using an AWS Secrets Manager secret and a publicly reachable OTLP endpoint, with direct integration support for Amazon CloudWatch, Datadog, Dynatrace, Elastic, Honeycomb, and OpenSearch, or any custom OTLP collector, complementing the existing daily CSV report.

A new 'Apply your cloud configuration to local sessions' toggle on the Configuration Sync page loads cloud-managed Steering files, custom agents, Skills, Powers, and Hooks into local Kiro IDE and CLI sessions at session start, without overwriting the local .kiro directory.

The repository picker in web sessions now supports selecting any branch when choosing a GitHub or GitLab repo, letting the agent clone and build from that branch instead of always starting from the default. A new 'Recent' section at the top of the picker groups recently used repositories per provider and hides automatically while searching.

Kiro Web lets you organize sessions into named groups from the sidebar or sessions page — create groups, move sessions in or out, and rename or dissolve groups at any time.

GitHub-connected chats now automatically create a working branch and a preview deployment for each change. The branch menu surfaces the deployment preview, diff review, pull request creation or navigation, CI check status, and base-branch pull all in one place. A 'Publish' action in the branch menu creates or reuses the pull request, merges it into the base branch, and triggers a production deployment; repository rules such as required checks and required reviews are enforced during Publish, with v0 linking directly to the pull request when manual attention is needed.

New langchain.mcp namespace (marked beta) provides MCPAdapter, which wraps any target accepted by fastmcp.Client — an HTTP(S) URL, local script, in-process server, MCPConfig naming multiple servers, or a fastmcp ClientGroup — as LangChain-compatible tools, enabling multi-server MCP fleets behind one adapter. MCPAdapter.list_tools(cache_mode=...) discovers and adapts MCP tools with client-side response caching: cache_mode='use' serves cached results within the server's TTL hint, 'refresh' repopulates the cache, 'bypass' skips it entirely, and 'persistent' is also usable per the shipped examples. as_langchain_tool(tool, client, *, elicitation=None) converts a single MCP tool for callers managing their own client lifecycle, and setting elicitation='interrupt' surfaces mid-call server questions as a LangGraph interrupt, pausing execution for human input before resuming the run. Adapted tool metadata is now structured under metadata['mcp']['tool'] (with annotations in snake_case and _meta) and metadata['mcp']['server']. MCP support requires the new mcp extra (pip install 'langchain[mcp]') and fastmcp>=4.0.0.

from langchain.agents import create_agent
from langchain.mcp import MCPAdapter

async with MCPAdapter("https://example.com/mcp") as adapter:
    agent = create_agent("anthropic:claude-sonnet-5", await adapter.list_tools())

async with MCPAdapter("https://example.com/mcp") as adapter:
    tools = await adapter.list_tools(cache_mode="refresh")
    agent = create_agent("anthropic:claude-sonnet-5", tools)

from langchain.mcp import as_langchain_tool
import fastmcp

client = fastmcp.Client("https://example.com/mcp")
tool = as_langchain_tool(mcp_tool, client, elicitation="interrupt")

from langchain.mcp import MCPAdapter

async with MCPAdapter("https://my-mcp-server.example.com") as adapter:
    tools = await adapter.list_tools(cache_mode="persistent")
    print(tools)

from fastmcp import ClientGroup
from langchain.mcp import MCPAdapter

group = ClientGroup([
    "https://mcp-server-a.example.com",
    "https://mcp-server-b.example.com",
])

async with MCPAdapter(group) as adapter:
    tools = await adapter.list_tools()
    # tools from all servers are available here

MCPAdapter.get_tools is renamed to list_tools — call sites using .get_tools() will break. convert_mcp_tool_to_langchain_tool is renamed to as_langchain_tool — imports of the old name will break. MCPAdapterTarget is no longer exported from langchain.mcp — code importing it from that path will break. A str MCP target must now be an HTTP(S) URL — bare strings that are not URLs are rejected.

openclaw update cleanup --dry-run previews retained migration originals eligible for removal before committing, and openclaw update cleanup (run with the Gateway stopped) permanently removes eligible originals; current SQLite history is preserved but rollback to removed originals is lost.

$ openclaw update cleanup --dry-run

The default for tools.sessions.visibility changed so unsandboxed sessions can work with other sessions of the same agent by default; operators needing narrower access should explicitly set tools.sessions.visibility to tree or self.

tools:
  sessions:
    visibility: tree

Adds OPENCLAW_DOCS_I18N_LOG_REJECTED_BODY=1 (also exposed as log_rejected_body in the publish repo's reusable locale workflow) to opt in to logging rejected translation chunks at the placeholder-validation boundary — capturing chunk ID, normalized masked input, returned translation, and error — plus failed leaf-fallback errors and rejected bodies at final-document validation.

Start and run a session from New Session without leaving the current page using Cmd/Ctrl+Enter (or Cmd/Ctrl+Shift+Enter when Modifier+Enter is already the send shortcut), retaining the selected local, cloud, or paired-device placement.

Adds a Linux desktop client installable via .deb or AppImage on x86-64 Linux, connecting to a local or remote Gateway and launching Quick Chat from the system tray or an X11 keyboard shortcut; AppImage updates are signature-verified.

Open the Home conversation in a right or bottom dock with Cmd/Ctrl+Shift+H, keeping the current page in view with options to preview, remove the work-context snapshot, or attach selected text.

Adds a format field to CommandCredentialConfig for ambient credentials, allowing a literal template (e.g. sk-ant-oat01-{}) so prefix-sniffing clients correctly classify the phantom token.

{
  "command_policies": {
    "credentials": {
      "claude-api": {
        "type": "proxy",
        "upstream": "https://api.anthropic.com",
        "credential_key": "keyring://anthropic:api.anthropic.com/example",
        "env_var": "ANTHROPIC_API_KEY",
        "inject_header": "x-api-key",
        "credential_format": "Bearer {}",
        "format": "sk-ant-oat01-{}"
      }
    }
  }
}

Adds --extends <PROFILE> flag to nono proxy, enabling profile layer composition at proxy startup. It requires --profile, is repeatable, and uses the same merge semantics as nono run --extends.

$ nono proxy --profile my-profile --extends extra-domains

Adds --strict-broker-path flag to sandbox args, refusing to start when a filesystem grant overlaps a directory on PATH — preventing sandboxed processes from planting hijack binaries that later run outside nono with full host privileges.

Adds three versioned web search tool types to the Messages API: web_search_20250305 for basic real-time search with max_uses, allowed_domains, blocked_domains, and user_location parameters; web_search_20260209, which introduces dynamic filtering where Claude writes and runs code to filter results before they reach the context window (its allowed_callers defaults to ["code_execution_20260120"]); and web_search_20260318, which adds a response_inclusion parameter — setting "response_inclusion": "excluded" drops nested server_tool_use and result block pairs already consumed by completed code execution calls, cutting output token costs. The allowed_callers field (across all versions) controls whether Claude calls web search directly (["direct"]) or via dynamic filtering through code execution; max_uses caps searches per request and returns a web_search_tool_result error with code max_uses_exceeded when exceeded; allowed_domains/blocked_domains scope search to bare domains (mutually exclusive — mixing both returns a 400 error); and user_location (type approximate, with city, region, country as ISO 3166-1 alpha-2, and IANA timezone) localizes results, rejecting unsupported country codes with a 400 error. Responses include web_search_result_location citation blocks (url, title, encrypted_index, cited_text up to 150 chars, none counted toward token usage), encrypted_content that must be replayed verbatim in multi-turn conversations, stop_reason: "pause_turn" for long-running search turns, and a server_tool_use.web_search_requests count in the usage block.

{
  "model": "claude-opus-5",
  "max_tokens": 1024,
  "messages": [{"role": "user", "content": "What are the latest CVEs affecting OpenSSL?"}],
  "tools": [{
    "type": "web_search_20250305",
    "name": "web_search",
    "max_uses": 3,
    "allowed_domains": ["nvd.nist.gov", "openssl.org"],
    "user_location": {
      "type": "approximate",
      "country": "US",
      "timezone": "America/New_York"
    }
  }]
}

{
  "model": "claude-opus-5",
  "max_tokens": 4096,
  "messages": [{"role": "user", "content": "Search for the current prices of AAPL and GOOGL, then calculate which has a better P/E ratio."}],
  "tools": [{
    "type": "web_search_20260318",
    "name": "web_search",
    "response_inclusion": "excluded"
  }]
}

{
  "model": "claude-opus-5",
  "max_tokens": 1024,
  "messages": [{"role": "user", "content": "What is the current price of Bitcoin?"}],
  "tools": [{
    "type": "web_search_20260209",
    "name": "web_search",
    "allowed_callers": ["direct"]
  }]
}

New model available on the Claude API, Amazon Bedrock, Google Cloud, Microsoft Foundry, and Claude Platform on AWS, with a 1M-token context window and 128K max output. Adaptive thinking is on by default with default thinking effort set to high on the Claude API and Claude Code, steerable per workload; knowledge cutoff is January 2026 with a retirement commitment of no sooner than June 30, 2027. Supports up to 300K output tokens on the Message Batches API when the output-300k-2026-03-24 beta header is set.

$ curl https://api.anthropic.com/v1/messages/batches \
  -H 'x-api-key: $ANTHROPIC_API_KEY' \
  -H 'anthropic-version: 2023-06-01' \
  -H 'anthropic-beta: output-300k-2026-03-24' \
  -H 'content-type: application/json' \
  -d '{"requests": [{"custom_id": "req-1", "params": {"model": "claude-sonnet-5", "max_tokens": 300000, "messages": [{"role": "user", "content": "Summarize this corpus."}]}}]}'

Introduces Claude Managed Agents with a new ant CLI (installable via brew install anthropics/tap/ant) that provisions agents with ant beta:agents create from a .agent.yaml config (model, system prompt, tools) and sandboxes with ant beta:environments create from a .environment.yaml config, supporting type: cloud with networking.type: unrestricted or self-hosted sandboxes. The Python SDK adds client.beta.sessions.create to bind a session to an agent ID and environment ID, and client.beta.sessions.events.stream / client.beta.sessions.events.send to open a real-time event stream and send user messages to a running session, with typed events including user.message, agent.message, agent.tool_use, and session.status_idle. The agent_toolset_20260401 tool type enables the full pre-built toolset (bash, file operations, web search), and managed agent sessions can be deployed on a schedule (cron).

$ AGENT_ID=$(ant beta:agents create --transform id --raw-output < coding-assistant.agent.yaml)
echo "Agent ID: $AGENT_ID"

name: quickstart-env
config:
  type: cloud
  networking:
    type: unrestricted

with client.beta.sessions.events.stream(session.id) as stream:
    client.beta.sessions.events.send(
        session.id,
        events=[{
            "type": "user.message",
            "content": [{"type": "text", "text": "Create a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt"}],
        }],
    )
    for event in stream:
        match event.type:
            case "agent.message":
                for block in event.content:
                    print(block.text, end="")
            case "agent.tool_use":
                print(f"\n[Using tool: {event.name}]")
            case "session.status_idle":
                print("\n\nAgent finished.")
                break

The /claude-api migrate subcommand performs automated Claude model migrations across a codebase: it swaps model IDs (including typed SDK constants such as Model.CLAUDE_OPUS_4_8 → Model.CLAUDE_OPUS_5), removes deprecated parameters (temperature, top_p, top_k), converts thinking: {type: 'enabled', budget_tokens: N} to thinking: {type: 'adaptive'}, cleans up beta headers (effort-2025-11-24, fine-grained-tool-streaming-2025-05-14, interleaved-thinking-2025-05-14), adds stop_reason: 'refusal' handling, calibrates output_config.effort, converts prefill to structured outputs, and configures refusal fallback via the server-side fallbacks parameter.

$ /claude-api migrate this project to claude-opus-5

$ /claude-api migrate everything under src/ to claude-opus-5

A new claude-api Agent Skill ships bundled with Claude Code (no installation required) and auto-activates when project files import anthropic (Python) or @anthropic-ai/sdk (TypeScript/JavaScript), or when editing files that use prompt caching, tool use, batch, or model references. It can be invoked manually via the /claude-api slash command, or installed into any Agent Skills-compatible environment via npx skills add https://github.com/anthropics/skills --skill claude-api or the Claude Code plugin command /plugin install claude-api@anthropic-agent-skills. It supports eight languages — Python, TypeScript, C#, Go, Java, PHP, Ruby, and cURL — with progressive, context-efficient documentation loading, detected automatically from project files (requirements.txt, tsconfig.json, go.mod, etc.), and covers the Managed Agents (beta) surface (client.beta.agents.*, client.beta.environments.*, client.beta.sessions.*, client.beta.vaults.*), which requires the managed-agents-2026-04-01 beta header set automatically by the SDK.

Claude Fable 5.1 launches on the Claude API, Amazon Bedrock, Claude Platform on AWS, Google Cloud, and Microsoft Foundry with a 1M-token context window, 128K max output tokens, always-on adaptive thinking at high default effort, and a June 2026 knowledge cutoff, priced at $10 / $50 USD per MTok. Claude Mythos 5.1 offers identical capabilities and pricing, available exclusively to Project Glasswing participants. Prompt cache reads on both models are priced at $0.25 USD per million tokens — 0.025x the base input price, versus 0.1x on other models.

In beta, add a role: "system" message with output_config.effort inside messages to change Claude Fable 5.1's thinking effort mid-conversation without invalidating the prompt cache; requires the mid-conversation-output-config-2026-07-01 beta header.

In beta, set clear_at: "next_user_message" on a mid-conversation role: "system" message so it applies only to the current turn without accumulating tokens or invalidating the prompt cache; requires the mid-conversation-system-clear-at-2026-08-21 beta header.

Thinking blocks produced by claude-fable-5-1 and claude-mythos-5-1 are forward-compatible only — the API silently drops a block replayed to an earlier model, though claude-fable-5-1 can accept thinking blocks from Claude Opus 5, Claude Fable 5, Claude Mythos 5, and earlier models. Editing an earlier turn invalidates the model's thinking blocks, and for accounts created on or after August 31, 2026, replaying a thinking block after the system prompt, tools, or an earlier message has changed returns a 400 error. A new thinking-binding-controls-2026-08-01 beta header surfaces dropped blocks in an input_transformations response field and exposes thinking.block_binding.prefix_mismatch_behavior to choose between rejecting or dropping mismatched thinking blocks.

On Claude Sonnet 5, setting temperature, top_p, or top_k to non-default values now returns a 400 error — sampling parameter overrides are no longer accepted. Manual extended thinking requests also return a 400 error (having been deprecated on Claude Sonnet 4.6); adaptive thinking runs on by default instead, so callers relying on either mechanism must migrate.

thinking.display accepts a new "updates" value in beta, adding display: "updates" to surface readable progress updates between tool calls during long-running agentic work: the thinking field is returned empty (as with "omitted") while short progress updates are streamed as text; requires the thinking-display-updates-2026-08-18 beta header.

Setting "processing": "agentic" on video input lets gemini-3.7-flash, gemini-3.6-flash, and gemini-3.5-flash-lite (via the Interactions and GenerateContent APIs) dynamically navigate a video's timeline, loading only the frames, audio, or transcript needed to answer a query — using up to 88% fewer tokens than static processing on long-form content, at the cost of higher time-to-first-token on clips under 5 minutes due to internal reasoning round-trips. Static processing remains available via "processing": "static" with "start_offset"/"end_offset" sub-fields to clip a time range and an "fps" sub-field for custom frame-sampling rate (e.g. 0.5). Different videos in the same request can independently be set to "agentic" or "static". Agentic responses interleave processing_call and processing_result steps (linked via id/call_id) in the steps array for progress traces, and token usage is broken out into total_thought_tokens (navigation reasoning) and total_tool_use_tokens (on-demand frames/audio/transcript). In stateless multi-turn conversations, these processing_call/processing_result steps must be echoed back in the next request's step_list to preserve video context.

{
  "parts": [
    {
      "file_data": {
        "uri": "<uploaded_video_uri>",
        "mime_type": "video/mp4",
        "processing": "agentic"
      }
    },
    {"type": "text", "text": "What are the three main arguments presented?"}
  ]
}

{
  "parts": [
    {
      "file_data": {
        "uri": "<lecture_uri>",
        "mime_type": "video/mp4",
        "processing": "agentic"
      }
    },
    {
      "file_data": {
        "uri": "<experiment_uri>",
        "mime_type": "video/mp4",
        "processing": "static"
      }
    },
    {"type": "text", "text": "Compare the lecture content with the experiment results."}
  ]
}