The AI Toolchain — issue 009, August 28, 2026

Launches the Router API (private preview): a single endpoint and Perplexity API key give OpenAI- and Anthropic-compatible access to open-weight models via POST https://api.perplexity.ai/router/v1/chat/completions (OpenAI Chat Completions format), POST https://api.perplexity.ai/router/v1/responses (stateless OpenAI Responses format, conversation passed via input), and POST https://api.perplexity.ai/router/v1/messages (Anthropic Messages format, drop-in via base URL https://api.perplexity.ai/router). A GET https://api.perplexity.ai/router/v1/models endpoint lists the catalog sorted by id with per-model input, output, and cache_read prices in USD per 1M tokens; six perplexity-hosted models are exposed under creator/model-name IDs — perplexity/deepseek-v4-flash-0731, perplexity/kimi-k3, perplexity/glm-5.2, perplexity/glm-5.3, perplexity/nemotron-3.5-lightning-30b-a3b, and perplexity/nemotron-3-ultra-550b-a55b — each usable through both Chat Completions and Messages shapes. Streaming is supported via stream: true with stream_options: {"include_usage": true} returning usage in the final SSE chunk; cache reads/writes bill at separate per-model rates and reasoning tokens bill at the output rate; requesting an unlisted model returns 400.

$ curl 'https://api.perplexity.ai/router/v1/models' \
  -H "Authorization: Bearer $PERPLEXITY_API_KEY" \
  | jq

$ curl -X POST 'https://api.perplexity.ai/router/v1/chat/completions' \
  -H "Authorization: Bearer $PERPLEXITY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "perplexity/kimi-k3", "max_tokens": 1024, "messages": [{"role": "user", "content": "Explain the CAP theorem in two sentences."}]}' | jq

$ curl 'https://api.perplexity.ai/router/v1/models' \
  -H "Authorization: Bearer $PERPLEXITY_API_KEY" | jq '.data[] | {id, input: .pricing.input, output: .pricing.output}'

$ curl -N -X POST 'https://api.perplexity.ai/router/v1/chat/completions' \
  -H "Authorization: Bearer $PERPLEXITY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "perplexity/kimi-k3", "max_tokens": 1024, "messages": [{"role": "user", "content": "Summarise zero-trust networking in three bullet points."}], "stream": true, "stream_options": {"include_usage": true}}'

The gateway chat completions endpoint (POST /router/v1/chat/completions) adds allowed_tools to restrict which function tools the model may call, and a reasoning_content field on response choices that can be replayed in a later assistant message to preserve chain-of-thought context across turns. Message parts gain a prompt_cache_breakpoint field, and a new prompt_cache_options object with ttl (5m, 1h, 24h) replaces the deprecated inline cache-retention setting; usage now reports cache_write_tokens alongside cached_tokens and audio_tokens under prompt_tokens_details. A new moderation object on the response exposes input and output moderation results with per-model flagged status, categories, category_scores, and category_applied_input_types.

$ curl --request POST \
  --url https://api.perplexity.ai/router/v1/chat/completions \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '{
    "model": "<model>",
    "prompt_cache_options": { "ttl": "1h" },
    "messages": [
      { "role": "user", "content": "Summarize the OWASP Top 10." }
    ]
  }'

$ curl --request POST \
  --url https://api.perplexity.ai/router/v1/chat/completions \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '{
    "model": "<model>",
    "messages": [
      { "role": "user", "content": "<user input>" }
    ]
  }' | jq '.moderation.output.results[0].flagged'

$ curl --request POST \
  --url https://api.perplexity.ai/router/v1/chat/completions \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '{
    "model": "<model>",
    "messages": [
      { "role": "user", "content": "Analyze this log for anomalies." },
      { "role": "assistant", "content": "<prior answer>", "reasoning_content": "<prior reasoning_content>" },
      { "role": "user", "content": "Which finding is highest severity?" }
    ]
  }'

Adds an Analytics API giving Perplexity Enterprise organizations programmatic access to usage time series via GET /analytics/v1 (dataset=credits, query_volume, daily_active_users, and others covering threads by connector/artifact/skill/space/workflow and task durations), with a bucket_width parameter and a member filter to restrict results to one organization member — though query_volume and daily_active_users are organization-only, daily-aggregated, and reject both bucket_width and member. A GET /analytics/v2 endpoint (computer-analytics-usage-v2-get) adds per-member daily breakdowns keyed by email, with credits split by the same axes as v1 and query_volume split by Feature, Project, and Comet (v1 also has model name and Model Family axes) — these breakdown axes are overlapping subsets, not partitions, so they don't sum to a total. Access requires an org-scoped analytics API key generated by an org admin via Settings → Organization → Computer.

$ curl -X GET 'https://api.perplexity.ai/analytics/v1?dataset=credits&bucket_width=1d' \
  -H 'Authorization: Bearer <your_api_key>'

$ curl -X GET 'https://api.perplexity.ai/analytics/v2?dataset=query_volume' \
  -H 'Authorization: Bearer <your_api_key>'

$ curl -X GET 'https://api.perplexity.ai/analytics/v1?dataset=credits&member=alice%40example.com' \
  -H 'Authorization: Bearer <your_api_key>'

The gateway messages endpoint (POST /gateway/messages) adds cache_control with type: "ephemeral" and a ttl field ("5m" supported; "1h" rejected until billed distinctly) on message content and tool_result.content blocks, reporting usage via new cache_creation fields ephemeral_5m_input_tokens and ephemeral_1h_input_tokens. It adds search_result as a supported content-block type alongside text, image and document, and document blocks now accept base64, plain text, or URL sources with optional title and context fields. Several OpenAI/Anthropic-style fields are recognized but not honored: service_tier (auto/standard_only) and output_config/context_management are accepted and ignored, while inference_geo, mcp_servers, speed ("fast"), fallbacks, fallback_credit_token, and container are explicitly rejected by validation.

$ curl https://api.perplexity.ai/gateway/messages \
  -H 'Authorization: Bearer $PERPLEXITY_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "sonar",
    "messages": [
      {
        "role": "user",
        "content": [
          {
            "type": "text",
            "text": "You are a security analyst. <large system context here>",
            "cache_control": {"type": "ephemeral", "ttl": "5m"}
          },
          {
            "type": "text",
            "text": "Summarize the latest threat intel."
          }
        ]
      }
    ]
  }'

The gateway responses endpoint (POST /router/v1/responses) exposes usage.input_tokens_details.cached_tokens, cache_write_tokens, and prompt_cache_key for prompt-cache tracking, plus usage.output_tokens_details.reasoning_tokens and a top-level reasoning object for chain-of-thought models. It supports parallel_tool_calls, max_tool_calls, and truncation (disabled) for tool-call control; store, background, service_tier, safety_identifier, and metadata for lifecycle and routing; a phase field (e.g. commentary) on output content items; sampling parameters temperature, top_p, presence_penalty, frequency_penalty, top_logprobs, and max_output_tokens; and lifecycle tracking via status, created_at, completed_at, and incomplete_details.reason.

$ curl --request POST \
  --url https://api.perplexity.ai/router/v1/responses \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '{
    "previous_response_id": "<prior_response_id>",
    "instructions": "You are a helpful assistant.",
    "temperature": 0.7,
    "reasoning": {},
    "store": true
  }'

$ curl --request POST \
  --url https://api.perplexity.ai/router/v1/responses \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '{
    "instructions": "Answer using the provided tools.",
    "tools": [{"function": {"name": "search", "description": "Search the web", "parameters": {}, "strict": true}}],
    "tool_choice": {"function": {"name": "search"}},
    "parallel_tool_calls": true,
    "max_tool_calls": 3,
    "truncation": "disabled"
  }'

The Router API automatically distributes requests across multiple underlying deployments for a model with no routing parameters or per-provider configuration (private preview, request access via [email protected]): weighted traffic splitting continuously adjusts on observed error rates, capacity and latency, shedding and restoring traffic as deployments degrade or recover. Multi-turn conversations are pinned to the same deployment where possible to preserve prompt-cache continuity, and automatic failover retries on an alternative deployment on provider error, rate limit or timeout, bounded by time-to-first-token and total-duration limits. Deterministic client errors surface immediately as 400 and are never retried; when every deployment is exhausted the API returns 429 with a Retry-After header, failed requests with no output are unbilled, and mid-stream failures end with an in-band error event billing only delivered tokens.

Adds perplexity/glm-5.3 as a new model available via chat completions, the Agent API, and the Router API, priced at $1.40 per million uncached-input tokens, $0.26 per million cached-input tokens, and $4.40 per million output tokens.

$ curl https://api.perplexity.ai/chat/completions \
  -H 'Authorization: Bearer <YOUR_API_KEY>' \
  -H 'Content-Type: application/json' \
  -d '{"model": "perplexity/glm-5.3", "messages": [{"role": "user", "content": "Explain prompt caching."}]}'

$ curl https://api.perplexity.ai/chat/completions \
  -H 'Authorization: Bearer <your_api_key>' \
  -H 'Content-Type: application/json' \
  -d '{"model": "perplexity/glm-5.3", "messages": [{"role": "user", "content": "Explain zero-day vulnerabilities."}]}'

Fine-tuning now supports Customer-Managed Encryption Keys (CMEK) backed by AWS KMS, Google Cloud KMS, or Azure Key Vault, letting customers supply their own cloud KMS key to control encryption of managed fine-tuning data; revoking the key prevents Fireworks from decrypting the training data.

BYOB support lets Fireworks read training datasets directly from your own cloud storage without persisting a copy, secured via OIDC-based IAM trust that scopes tokens to a specific Fireworks account ID so credentials from other accounts are rejected.

Adds qwen/qwen3.8-27b to the Groq API with a 131,042-token context window, priced at $0.80/M input tokens and $4.00/M output tokens.

$ curl https://api.groq.com/openai/v1/chat/completions \
  -H 'Authorization: Bearer $GROQ_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "qwen/qwen3.8-27b",
    "messages": [{"role": "user", "content": "Analyze this document: <document_text>"}]
  }'

GPT-5.6 now accepts images at their original dimensions using the original or auto image detail settings, avoiding downscaling.

$ curl https://api.openai.com/v1/chat/completions \
  -H 'Authorization: Bearer $OPENAI_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"model": "gpt-5.6", "messages": [{"role": "user", "content": [{"type": "image_url", "image_url": {"url": "https://example.com/screenshot.png", "detail": "original"}}]}]}'

GPT-5.6 launches as a family of models: gpt-5.6-sol (routed via the gpt-5.6 alias) for high-intelligence workloads, gpt-5.6-terra for balanced workloads, and gpt-5.6-luna for high-volume workloads.

Adds mtp_mode config key accepting 'auto' | 'on' | 'off' to control Multi-Token Prediction; valid inline Qwen3.5/3.6 MTP artifacts now default to auto (on) while Gemma remains opt-in; DARKBLOOM_CBV2_MTP=0 env var remains an independent rollback path. Config schema v3 migrates legacy generated mtp = false values to auto and retains legacy mtp = true as on, so upgraded providers receive the new policy automatically.

mtp_mode = "off"

Adds production serving of Qwen3-VL (qwen3_vl_moe architecture) through the ContinuousBatchingV2 path, with per-row M-RoPE for text, causal visual spans and every DeepStack level for image prefill, and fused homogeneous routed gate/up expert projections at load time.

Adds a competing inference check to darkbloom doctor that warns when local inference processes (e.g. Ollama on port 11434, llama-server) are detected consuming unified memory alongside the provider.

The new beta Sessions API adds POST /v1/sessions to create a managed agent session, GET /v1/sessions to list sessions in the caller's workspace, GET /v1/sessions/{session_id} to retrieve one, POST /v1/sessions/{session_id} to update a session mid-run (only tools and mcp_servers are updatable, full-replacement semantics), DELETE /v1/sessions/{session_id} to permanently delete a session (returns a session_deleted object), and POST /v1/sessions/{session_id}/archive to archive a session.

Sessions can attach a memory store via BetaManagedAgentsMemoryStoreResourceParam (a memstore_... ID with read_write or read_only access and per-attachment instructions up to 4096 chars rendered into the system prompt), mount a Files API upload into the container via BetaManagedAgentsFileResourceParams (optional mount_path, defaulting to /mnt/session/uploads/<file_id>), and mount a GitHub repository via BetaManagedAgentsGitHubRepositoryResourceParams, with BetaManagedAgentsBranchCheckout and BetaManagedAgentsCommitCheckout pinning the repo to a branch name or commit SHA.

CacheControlEphemeral objects gain a ttl field ('5m' or '1h', default '5m') to control prompt-cache lifetime per content block; a top-level cache_control parameter applies the same TTL options as a breakpoint on the last cacheable block automatically; and setting max_tokens: 0 populates the prompt cache without generating a response.

$ curl https://api.anthropic.com/v1/messages \
  -H 'x-api-key: $ANTHROPIC_API_KEY' \
  -H 'anthropic-version: 2023-06-01' \
  -H 'content-type: application/json' \
  -d '{
    "model": "claude-sonnet-5",
    "max_tokens": 1024,
    "system": [
      {
        "type": "text",
        "text": "<large system prompt>",
        "cache_control": {"type": "ephemeral", "ttl": "1h"}
      }
    ],
    "messages": [{"role": "user", "content": "Summarize the above."}]
  }'

$ curl https://api.anthropic.com/v1/messages \
  -H 'x-api-key: $ANTHROPIC_API_KEY' \
  -H 'anthropic-version: 2023-06-01' \
  -H 'content-type: application/json' \
  -d '{
    "model": "claude-sonnet-5",
    "max_tokens": 0,
    "cache_control": {"type": "ephemeral", "ttl": "1h"},
    "messages": [{"role": "user", "content": "<large shared context>"}]
  }'

The new output_config parameter sets effort ('low', 'medium', 'high', 'xhigh', 'max') and format (a JSONOutputFormat with schema and type: 'json_schema') to control structured output from a Messages request.

$ curl https://api.anthropic.com/v1/messages \
  -H 'x-api-key: $ANTHROPIC_API_KEY' \
  -H 'anthropic-version: 2023-06-01' \
  -H 'content-type: application/json' \
  -d '{
    "model": "claude-sonnet-5",
    "max_tokens": 512,
    "output_config": {
      "format": {
        "type": "json_schema",
        "schema": {
          "type": "object",
          "properties": {
            "severity": {"type": "string"},
            "cve": {"type": "string"},
            "summary": {"type": "string"}
          },
          "required": ["severity", "cve", "summary"]
        }
      }
    },
    "messages": [{"role": "user", "content": "Analyze this vulnerability report: <report>"}]
  }'

The Admin API is now available in the ant CLI and the Python, TypeScript, C#, Go, Java, PHP, and Ruby SDKs under client.beta.organization, covering organization info, members, invites, workspaces and workspace members, API keys, rate limits, service accounts, workload identity federation issuers and rules, and customer-managed encryption keys. The CLI and SDKs read an Admin API key from ANTHROPIC_API_KEY or an org:admin OAuth token from ANTHROPIC_AUTH_TOKEN.

client.beta.files and client.beta.skills no longer send the files-api-2025-04-14 and skills-2025-10-02 beta headers, across Python SDK 1.2.0, TypeScript SDK 0.122.0, Go SDK 1.68.0, Java SDK 2.59.0, Ruby SDK 1.67.0, and C# SDK 12.44.0 — the Files and Skills APIs are now GA. The beta BetaSkill type is renamed to BetaContainerSkill in these SDK versions, and client.beta.files/client.beta.skills now return the GA response shapes (matching client.files/client.skills); code relying on the beta-specific response shapes breaks unless it still sends the beta headers explicitly.

BetaManagedAgentsBudgetLimit lets a session set max_list_cost (an amount plus ISO-4217 currency, USD only) as a hard spend ceiling; the session stops issuing new model requests once tracked list cost reaches the limit.

Sessions can opt into event_deltas on stream connections to receive BetaManagedAgentsStartEvent/BetaManagedAgentsDeltaEvent/BetaManagedAgentsDeltaContent previews of agent.message and agent.thinking. BetaManagedAgentsSessionUsageEvent reports periodic cumulative token usage and tracked list cost; BetaManagedAgentsSessionStats exposes active_seconds and duration_seconds; BetaManagedAgentsCacheCreationUsage breaks prompt-cache creation into ephemeral_1h_input_tokens and ephemeral_5m_input_tokens; and BetaManagedAgentsServerToolUsage tracks cumulative web_fetch_requests and web_search_requests.

The container parameter (ContainerParams with id and skills) reuses a container across requests and loads up to 20 named skills (type 'anthropic' or 'custom', optional version); the new ContainerUploadBlockParam content block (type: 'container_upload', file_id) uploads a file into the container's input directory as part of a message.

Compliance API session endpoints for Cowork and Claude Code sessions are now generally available. Compliance API local session endpoints also return transcripts for Claude Science sessions via product_surface value claude_science (beta, Claude Enterprise), and for Claude for Microsoft 365 sessions in Excel, PowerPoint, Word, and Outlook via product_surface values beginning with office_agents (beta, Claude Enterprise), using the existing Compliance Access Key and read:compliance_user_data scope.

BetaManagedAgentsMultiagentParams lets a primary thread orchestrate subagents drawn from a named roster; roster entries can be agent ID strings, versioned BetaManagedAgentsAgentParams references, self, or BetaManagedAgentsAdvisorParams, which occupies the reserved roster name anthropic.advisor.

Sessions support BetaManagedAgentsSystemMessageEvent (system.message type) to append a role: 'system' turn mid-conversation, BetaManagedAgentsUserToolResultEvent to deliver client-side tool results back to the session, and BetaManagedAgentsSessionUpdatedEvent, emitted when UpdateSession changes at least one field, carrying only the changed fields (new configuration applies from the next turn).

Adds five new model identifiers: claude-sonnet-5 (coding/agents), claude-fable-5 (hard knowledge/coding), claude-mythos-5 (cybersecurity and biology research), claude-opus-5 (long-running agents), and claude-mythos-preview (strongest in coding and cybersecurity).

The anthropic-user-profile-id request header (requires the user-profiles beta header) attributes API requests to a specific user profile when acting on behalf of a party other than your organization.

The inference_geo parameter pins inference processing to a specific geographic region per request, falling back to the workspace's default_inference_geo when omitted; the service_tier parameter ('auto' or 'standard_only') chooses between priority and standard capacity per request.

BetaManagedAgentsOutcomeEvaluationResource tracks grader-scored outcomes defined via define_outcome events, moving through states pending, running, evaluating, satisfied, needs_revision, max_iterations_reached, failed, and interrupted.

The Claude Console adds personal keys and service account keys scoped to a specific workspace, or to admin endpoints across any workspace the linked account can access — enabling per-account usage tracking and legitimacy enforcement by org admins.

A new POST https://generativelanguage.googleapis.com/v1beta/interactions endpoint with model: gemini-3.5-transcribe converts uploaded audio to text, returning the transcript in interaction.output_text. It supports generation_config.transcription_config.language_codes (BCP-47 list, e.g. ["es-ES"], or []/omitted for automatic detection across 85+ locales with dynamic code-switching), generation_config.transcription_config.custom_vocabulary (up to 1,000 terms, best results with up to 100), generation_config.transcription_config.mode.diarization_mode: "speaker" (up to 8 speakers, 3+ experimental, tagging segments spk_1, spk_2, etc.), generation_config.transcription_config.mode.timestamp_granularities: ["word"] for word-level start/end offsets, and generation_config.transcription_config.mode of {"type": "verbatim"} (default, preserves fillers) or "smart" (removes disfluencies, applies structured formatting).

$ curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3.5-transcribe",
    "input": [
      {
        "type": "audio",
        "uri": "YOUR_FILE_URI",
        "mime_type": "audio/mp3"
      }
    ],
    "generation_config": {
      "transcription_config": {
        "mode": {
          "type": "verbatim",
          "diarization_mode": "speaker",
          "timestamp_granularities": ["word"]
        }
      }
    }
  }'

$ curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3.5-transcribe",
    "input": [
      {
        "type": "audio",
        "uri": "YOUR_FILE_URI",
        "mime_type": "audio/mp3"
      }
    ],
    "generation_config": {
      "transcription_config": {
        "custom_vocabulary": ["Gemini", "Kubernetes", "BigQuery"],
        "mode": "smart"
      }
    }
  }'

The GA gemini-omni-1.1-flash model adds a resolution parameter in video_config supporting 360p, 720p (default), 1080p, and 4k/4K outputs (1080p and 4K use upscaling); an extend task that generates seamless continuations appended to an existing clip (or via a direct prompt such as "Continue the scene."), extending up to 40 seconds total in 10-second increments using the last 10 seconds of the original clip as context; and an image_to_video task accepting up to 2 images for first/last-frame interpolation, also exposed via first_frame_b64 and last_frame_b64 fields, including looping video by setting <FIRST_FRAME> and <LAST_FRAME> to the same image. It supports reference media via <IMAGE_REF_N> and <VIDEO_REF_N> prompt tags and explicit declaration syntax ([# Sources <FIRST_FRAME>@Image1 <LAST_FRAME>@Image2], [# References <VIDEO_REF_0>@Video1]), plus <VIDEO_0> and <PREVIOUS_VIDEO> source tags for editing and multi-turn extension, and native audio.

$ curl https://generativelanguage.googleapis.com/v1beta/models/gemini-omni-1.1-flash:generateContent \
  -H 'Content-Type: application/json' \
  -d '{
    "contents": [{"parts": [{"text": "Continue this video with a sunset scene"}]}],
    "generationConfig": {
      "task": "extend",
      "video_config": {
        "resolution": "1080p"
      }
    }
  }'

$ curl https://generativelanguage.googleapis.com/v1beta/models/gemini-omni-1.1-flash:generateContent \
  -H 'Content-Type: application/json' \
  -d '{
    "contents": [{"parts": [
      {"inline_data": {"mime_type": "image/jpeg", "data": "<first_frame_base64>"}},
      {"inline_data": {"mime_type": "image/jpeg", "data": "<last_frame_base64>"}}
    ]}],
    "generationConfig": {
      "task": "image_to_video",
      "video_config": {"resolution": "720p"}
    }
  }'

$ curl -X POST https://api.gemini.example/v1/video:generate \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "gemini-omni-1.1-flash",
    "input": "A drone shot of a mountain landscape at sunrise.",
    "resolution": "1080p"
  }'

$ curl -X POST https://api.gemini.example/v1/video:generate \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "gemini-omni-1.1-flash",
    "first_frame_b64": "'$FIRST_FRAME_B64'",
    "last_frame_b64": "'$LAST_FRAME_B64'",
    "input": "A smooth cinematic transition from a lush green forest at sunrise to a snowy forest under a starry night sky."
  }'

{
  "model": "gemini-omni-1.1-flash",
  "contents": [{"parts": [{"text": "A drone flyover of a mountain range at sunset"}]}],
  "video_config": {
    "resolution": "4k"
  }
}

{
  "model": "gemini-omni-1.1-flash",
  "task": "image_to_video",
  "contents": [
    {"parts": [{"inline_data": {"mime_type": "image/jpeg", "data": "<first_frame_base64>"}}]},
    {"parts": [{"inline_data": {"mime_type": "image/jpeg", "data": "<last_frame_base64>"}}]}
  ],
  "video_config": {
    "resolution": "720p"
  }
}

{
  "model": "gemini-omni-1.1-flash",
  "task": "extend",
  "contents": [
    {"parts": [{"inline_data": {"mime_type": "video/mp4", "data": "<source_video_base64>"}}]}
  ],
  "video_config": {
    "resolution": "1080p"
  }
}

The Interactions API (POST /v1beta/interactions) is now the default interface for building with Gemini models and agents as of June 2026, superseding the generateContent API, which is now considered legacy; existing integrations continue to be supported but new projects should migrate, and a migration guide and Interactions Overview are available. The Interactions API also adds streaming support for real-time tokens, incremental thoughts, and tool call events.

The new gemini-3.5-transcribe-live model provides low-latency, bidirectional streaming speech-to-text over WebSockets via the Live API, with interim and finalized transcription events, Smart transcription mode, and configurable Voice Activity Detection (VAD) strategies. The Live API's Live Transcription also adds automatic language detection and custom vocabulary, supporting live subtitles, meeting transcription, voice dictation, and customer call logging.

Adds a ThinkingLevel enum (e.g. HIGH) to GenerationConfig in the Java SDK, exposed as com.google.genai.gaos.models.interactions.ThinkingLevel, to control reasoning depth. New Java SDK classes CreateModelInteraction, InteractionsInput, GenerationConfig, Interaction, and CreateInteractionRequestBody under com.google.genai.gaos.models.interactions support structured reasoning API calls.

New POST /v1/endpoints deploys a dedicated, reserved-hardware inference endpoint for any supported model, starting automatically after creation; GET /v1/endpoints lists endpoints filterable by dedicated or serverless type; GET /v1/endpoints/{id} retrieves state, configuration and scaling settings; PATCH /v1/endpoints/{id} updates display name, autoscaling, or start/stop state; DELETE /v1/endpoints/{id} removes an endpoint. LoRA adapters can be attached, listed and removed via POST /v1/endpoints/{id}/adapters, GET /v1/endpoints/{id}/adapters, and DELETE /v1/endpoints/{id}/adapters/{adapter}, with multiple adapters servable simultaneously on one endpoint. GET /v1/hardware lists available hardware configurations filterable by model, and POST /v1/models/upload uploads a custom or fine-tuned model from Hugging Face or S3 for dedicated serving; per-endpoint settings also cover replica count, hardware, decoding optimizations and prompt caching.

The Together CLI gains a tg batches command group for asynchronous batch inference. tg batches submit uploads a local JSONL file or references an existing file ID to create a job against chat.completions, audio.transcriptions, or audio.translations; tg batches list (alias ls), tg batches get/retrieve (alias get), and tg batches cancel manage the job lifecycle; tg batches download streams results to stdout or writes output and error files to disk with --output.

$ tg batches download <job-id> --output ./results/

$ tg batches submit ./requests.jsonl chat.completions

$ tg batches get [BATCH_ID] --output ./out

$ tg batches ls
tg batches cancel [BATCH_ID]

$ tg batches ls
tg batches cancel <job-id>

GPU clusters (both Kubernetes and Slurm-backed) now expose a kubeconfig for direct access to the cluster's Kubernetes API. The CLI adds tg beta clusters get-credentials [CLUSTER_ID] --set-default-context to download and set the kubeconfig, and tg beta clusters list to enumerate cluster IDs; the cluster details page at api.together.ai/clusters also offers view/copy or download of the kubeconfig once a cluster is ready. Access is role-scoped: the Kubeconfig row is visible to all project members; with OIDC enabled, Admin Kubeconfig is restricted to project admins while OIDC Kubeconfig remains available to admins and editors.

$ tg beta clusters get-credentials <CLUSTER_ID> --set-default-context

$ tg beta clusters list

New GET /v1/billing/usage endpoint (billing-usage) returns an organization's monthly billing usage as cost-annotated line items grouped by time window, at daily or hourly granularity in UTC.

Adds Qwen/Qwen3.8-2.4T-A95B (FP4 quantization) to serverless, priced at $2.50 input / $6.25 output / $0.50 cached input per 1M tokens, and nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-FP8 for deployment on dedicated endpoints.

$ curl https://api.together.xyz/v1/chat/completions \
  -H 'Authorization: Bearer $TOGETHER_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"model": "Qwen/Qwen3.8-2.4T-A95B", "messages": [{"role": "user", "content": "Explain buffer overflows."}]}'

nvidia/Nemotron-3-ultra-550b-a55b, pearl-ai/gemma-4-31b-it, deepseek-ai/DeepSeek-V4-Pro, and moonshotai/Kimi-K2.7-Code have been deprecated and are no longer available on serverless; use deepseek-ai/DeepSeek-V4-Pro-0813 in place of deepseek-ai/DeepSeek-V4-Pro.

Connecting a Vercel project via Integrations settings now creates a dedicated API key per linked Vercel project, automatically set as the TOGETHER_API_KEY environment variable in that Vercel project.

API key expiration can now be set at creation time in the console, choosing 1 hour, 1 day, 7 days, 30 days, or a custom date. Scheduled expiration on a project API key can be cancelled via the three-dot menu (Cancel expiration), keeping the key active indefinitely.

New model zai-org/GLM-5.3-Flash is available on serverless with a 1,000,000-token context length, FP8 quantization, function calling and structured outputs, priced at $0.15 input / $0.50 output / $0.03 cached input per 1M tokens.

File uploads for fine-tuning now support an optional progress_callback parameter accepting a callable that receives FileUploadProgress events exposing event.uploaded_bytes and event.total_bytes for real-time upload progress tracking in the Python SDK.

Project collaborators can now leave a project themselves from Settings > Project > Collaborators or the Projects list in Organization Settings, without requiring an admin action; a guard prevents the last admin from leaving before promoting another collaborator.

ACH bank transfers, previously enterprise-only, are now available to all customers: link a U.S. bank account with instant verification from billing settings, set it as default, and purchase credits directly; credits deposit after the transfer clears, typically 1-3 business days.

The new runpod-flash Python SDK adds an @endpoint decorator that deploys GPU-accelerated Python functions directly to RunPod Serverless, letting you specify GPU type, worker count, and pip dependencies inline with no Dockerfile or registry push required. The accompanying flash run CLI command serves Flash-decorated endpoints locally and as production APIs behind a FastAPI router with a single command, and the resulting Flash endpoints are full RunPod Serverless endpoints with autoscaling, cold-start management, and access to RunPod's full GPU fleet.

$ pip install runpod-flash

$ flash run

Sandbox.create() gains block_network=True to drop all outbound traffic, outbound_cidr_allowlist to restrict outbound traffic to given CIDR ranges (any protocol), and outbound_domain_allowlist (Beta) to restrict outbound TLS traffic on port 443 to specified domains with *. wildcard subdomain support — blocked connections are logged to the Sandbox system output stream, and the two allowlists combine additively. inbound_cidr_allowlist restricts which source IPs can connect inbound via tunnels and Connect Tokens. A running Sandbox's outbound policy can be swapped without restart via _experimental_set_outbound_network_policy() (Python), sb.updateNetworkPolicy() (JS) or sb.UpdateNetworkPolicy() (Go), immediately terminating connections that no longer match. sb.create_connect_token(user_metadata=..., port=...) (Python) / sb.createConnectToken() (JS) / sb.CreateConnectToken() (Go) issues authenticated HTTP/WebSocket Connect Tokens, passable via Authorization header, _modal_connect_token query param, or _modal_connect_token cookie, with the server receiving an unspoofable X-Verified-User-Data header. h2_ports exposes HTTP/2 + TLS tunnels alongside the existing encrypted_ports and unencrypted_ports.

sb = modal.Sandbox.create(
    "sleep", "infinity",
    outbound_domain_allowlist=["*"],
    outbound_cidr_allowlist=["0.0.0.0/0"],
    app=app,
)

# ... dependencies installed ...

sb._experimental_set_outbound_network_policy(
    outbound_domain_allowlist=["api.openai.com", "*.github.com"],
    outbound_cidr_allowlist=[],
)

sb = modal.Sandbox.create(
    "bash", "-c", "python3 -m http.server 8080",
    app=my_app,
)

creds = sb.create_connect_token(user_metadata={"user_id": "alice"}, port=8080)

import requests
resp = requests.get(creds.url, headers={"Authorization": f"Bearer {creds.token}"})
print(resp.text)

sb = modal.Sandbox.create(
    "sleep", "infinity",
    outbound_cidr_allowlist=["52.0.0.0/8", "10.0.1.0/24"],
    app=app,
)

readiness_probe on Sandbox.create() supports modal.Probe.with_tcp(port) and modal.Probe.with_exec(cmd, interval_ms=...), gated by sb.wait_until_ready(). idle_timeout auto-terminates a Sandbox after inactivity, where activity means sb.exec(...) running, sb.stdin.write() being called, or an open Tunnel TCP connection; timeout is configurable up to 24 hours (default 5 minutes). The modal.Sandbox interface adds Sandbox.create, sb.exec(...), sb.terminate(), sb.detach(), sb.poll(), and sb.wait_until_ready(), and a five-stage lifecycle (Created, Scheduled, Started, Ready, Finished) is observable via the dashboard and sandbox.poll() exit codes. The TypeScript (modal npm package) and Go (github.com/modal-labs/modal-client/go) SDKs now expose the same Sandbox API, including modal.sandboxes.create(...), sb.exec(...), Probe.withTcp(port), Probe.withExec(cmd, { intervalMs }), and sb.waitUntilReady().

sb = modal.Sandbox.create(
    "python3", "-m", "http.server", "8080",
    readiness_probe=modal.Probe.with_tcp(8080),
    app=sb_app,
)
sb.wait_until_ready()
# server is now accepting connections
sb.terminate()
sb.detach()

sb = modal.Sandbox.create(
    "bash", "-c", "sleep 5 && touch /tmp/ready && sleep 3600",
    readiness_probe=modal.Probe.with_exec(
        "sh", "-c", "test -f /tmp/ready",
        interval_ms=250,
    ),
    app=sb_app,
)
sb.wait_until_ready()
p = sb.exec("cat", "/tmp/ready")
sb.terminate()
sb.detach()

sb = modal.Sandbox.create(
    app=sb_app,
    timeout=24*60*60,
    idle_timeout=30*60,
)
sb.detach()

The modal CLI gains a --profile global option for ad hoc profile selection without editing configuration files, e.g. modal --profile <profile-name> run my_app.py.

$ modal --profile my-staging-profile run my_app.py

$ modal --profile <profile-name> run my_app.py

Adds a Steer capability that lets users send follow-up context to Agent mid-turn rather than queuing it until the current turn completes. Settings > Personalization lets users choose Steer or Queue behavior separately for Conversations and Projects, and Cmd+Enter (Mac) / Ctrl+Enter (Windows/Linux) toggles the opposite behavior for a single message.

Enterprise admins can set per-provider model policies (Enable all, Enable selected, or Disabled) and control which models are available in individual Workspaces via Advanced settings. Admins can also define an approved model set per workspace, and Intelligent Model Routing then selects automatically only from within that approved set, keeping AI usage within company policy.

Introduces Intelligent Model Routing, which dynamically selects the optimal AI model for each task — balancing quality, speed, and cost — without requiring the user to manually choose a model, delivering the same output quality at 65% lower cost compared to the previous Max Mode. Core and Pro users retain the ability to manually select specific models instead of using automatic routing.

New Free Mode lets users chat, explore, and build without consuming Power Mode or Max Mode credits, with remaining allowance and reset timing visible in Settings > Usage. Replit now notifies users when their work escalates from Free Mode to higher-powered, cost-incurring modes, with an option to override and stay in Free Mode; Free Mode's usefulness also expanded because Intelligent Model Routing delivers comparable quality at lower cost.

New Level 3 security scan combines dependency/package checks, Agent static analysis of source code, and an external black-box test of the live Preview, with the source-code review and live test running in parallel.

A new devin.agentWindow.location config setting lets you split the Agent Command Center into a separate window from the editor. Any number of agent windows can now run side by side, and the Agent Command Center follows whichever Windsurf space is selected instead of being tied to one folder, converting an editor window in place with no reload or save prompt.

Session tabs and the command palette now offer Copy Session URL for sharing or referencing individual sessions, and sessions can now be renamed from the tab dropdown.

New settings control whether integrated terminal activity and local user-edit activity are shared with ACP agents; both are on by default.

Hooks now run for worktrees created from a Devin Local session, copying .env files and other untracked setup files before the session starts.

On Windows, Install Devin CLI now writes a shim to the bundled CLI so updating Devin Desktop also updates the devin command.

A new inline /usage command in the Warp Agent CLI displays plan details, credit usage, and billing links directly from the terminal, letting users check their current plan, remaining credits, and billing links without leaving the session.

$ /usage

$ /usage

Warp Agent CLI now accepts --title and --parent-run-id flags so third-party harnesses can set a run's title and orchestration lineage.

Warp Factories launched in Early Access, providing an Activity view that groups tasks into Triage, Planning, and Building columns with linked issues, implementation plans, channels, and 'Needs attention' statuses, plus a 'software factories as code' YAML configuration defining repositories, agent models and roles, and a GitHub pull-request trigger.

Workspace admins can now promote, demote, or remove team members on their current team, shown with 'Workspace admin'/'Workspace owner' badges in the team members list. Teamless users in a native workspace now see an Admin Panel link and joinable teams on the Teams settings page instead of team creation. Disabled team/workspace members are now shown grayed out with an explanatory tooltip instead of appearing active.

A new setting makes bare right-click paste from the clipboard, with Shift+right-click still opening the context menu; a 'Paste' item has also been added to the terminal block list's right-click context menu.

Usage displays — agent block usage, conversation footer, usage history, and task details — now show a per-category dollar cost breakdown alongside credits.

Vim keybindings now work in several more multi-line editors — commit messages, suggested-rule content, env var commands, compact AI inputs, queued-prompt editing, and workflow dynamic enums — as well as in the rule editor, when vim mode is enabled.

The /spec run command opens a dedicated full-screen task execution view for V3 spec runs, with real-time progress tracking and task scope selection before execution begins.

$ /spec run

Adds the GLM-5.3 Flash model (also known as Ox Alpha), first listed in v1.35.0 and detailed in v0.1.19 with image support and a one-million-token context window.

Makes MiniMax M3 and MiniMax M2.7 available at no cost through September 5, 2026, and shows a FREE badge on free models in the model picker so cost is visible before selecting.

Azure providers can now authenticate using an active az login session instead of an API key. Use az login --tenant TENANT_ID to target a non-default tenant, and az account set --subscription NAME_OR_ID to select the subscription before OpenCode discovers deployed models. Set AZURE_RESOURCE_GROUP to skip subscription-level resource listing and query a known resource group directly. When automatic control-plane discovery of deployed models isn't available, map a model to its deployment name explicitly under the azure provider key (e.g. {"azure": {"gpt-5-mini": "gpt-production"}}); otherwise OpenCode auto-discovers models from the active subscription or falls back to the Azure model catalog. Access tokens refresh automatically through the Azure CLI, including CLI versions earlier than 2.54.0, requiring re-authentication only when the CLI session itself expires.

$ az login --tenant TENANT_ID && opencode

$ AZURE_RESOURCE_GROUP=my-rg opencode

$ az account set --subscription NAME_OR_ID && opencode

$ az login --tenant TENANT_ID

$ az account set --subscription NAME_OR_ID

{
  "azure": {
    "gpt-5-mini": "gpt-production"
  }
}

Adds grok-4.6 (Grok 4.6) at $12.00/M input tokens (≤200K context) and $1.00/M (>200K context), with per-request limits of 390 input, 32,500 cached, 120 output tokens. Adds glm-5.3-flash (GLM-5.3-Flash) at $0.15/M input and $0.03/M output tokens, with limits of 1,000 input, 55,000 cached, 200 output tokens. Adds qwen3.8-flash (Qwen3.8 Flash) at $0.15/M input and $0.47/M output tokens, with limits of 600 input, 58,000 cached, 200 output tokens.

Cline Desktop ships a code-signed x64 Windows installer with the same auto-update feed as macOS. Windows updates now download in the background and install on restart, and the MCP settings path falls back to USERPROFILE when HOME is unset.

Global rules at ~/Cline/Rules are now discovered in addition to ~/Documents/Cline/Rules, fixing rules that never reached the model on WSL and headless installs.

Session search now covers full indexed history via the command bar (Cmd/Ctrl+P) with server-ranked results.

Agent-created schedules are now stored in ~/.cline/schedules and appear on the Schedules page, replacing per-chat-folder scatter. Finished scheduled sessions now surface their final answer: the completing step auto-expands, is labeled 'Scheduled task completed' (or failed), and its summary renders as markdown. Suggested routine templates now request a specific final report so scheduled runs end with readable output.

Adds --restricted flag (or CLAUDE_CODE_RESTRICTED=1 env var) that strips command/code-execution tools and WebFetch, confines file tools to the working directory, refuses bypassPermissions, and ignores user, project, and local settings files — unless specific tools are re-enabled via --tools.

$ CLAUDE_CODE_RESTRICTED=1 claude --tools Edit,View

Adds attach, logs, stop, respawn, and rm subcommands to claude --help for managing background sessions; the --resume message for a running background session now names the exact claude attach <id> command to use.

$ claude attach <id>

Adds /claude-api cost-optimize subcommand to profile an existing project's Claude API spend and work through cost levers (caching, token hygiene, batch, effort, model choice) one measured change at a time.

$ /claude-api cost-optimize

Adds {id, text, cooldownSessions, priority} entries, tipsFile, and label to spinnerTipsOverride so organizations can rotate custom tips alongside built-in ones.

spinnerTipsOverride:
  tipsFile: /etc/claude-code/org-tips.json
  label: "Acme Corp Tips"
  entries:
    - id: tip-cache
      text: "Use prompt caching on repeated context to cut costs by up to 90%."
      priority: 10
      cooldownSessions: 3

Adds experimental.cacheTtl ("5m" or "1h") to agent frontmatter for a per-agent prompt cache TTL when no subagent TTL setting is configured.

experimental:
  cacheTtl: "1h"

Adds SendFeedback tool so Claude can draft a feedback report during a session for you to review and send from /feedback; disable with the feedbackDrafts setting.

{
  "feedbackDrafts": false
}

Adds claude self-hosted-runner --client-label <label> (or SELF_HOSTED_RUNNER_CLIENT_LABEL) to override the label the runner registers with (default: hostname).

$ claude self-hosted-runner --client-label prod-worker-1

Adds cross-session messaging via SendMessage and ListAgents between sessions on the same machine, now supported on Bedrock, Vertex, Foundry, and when telemetry is disabled. Peer messages collapse by default to a one-line preview (Message from @<sender>: <first line>), with Ctrl+O expanding the full body.

Adds PreModelSwitch and PostModelSwitch hook events, letting hooks block, confirm, or annotate a model switch; SessionStart resume hooks now also receive session staleness and the estimated re-cache cost.

ANTHROPIC_CUSTOM_HEADERS set from managed or project settings now requires approval when it sets a credential, org/tenant, routing, or API-behavior header (e.g. Authorization, Host). Server-managed settings that terminate sandbox TLS, route sandbox traffic through a custom proxy, inject credentials, or weaken sandbox isolation likewise now require approval before they apply.

Project-level .claude/settings.json env no longer sets CLAUDE_CONFIG_DIR, CLAUDE_CODE_TMPDIR, or TMPDIR/TMP/TEMP; these must now be set in shell, user, or managed settings.