The AI Toolchain — issue 024, September 12, 2026

Adds Settings → Workspace → Default Chat Visibility with three options — Private, Team can view, and Team can edit — letting team owners control the default visibility for all new chats.⁠︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄⁠ This is a breaking change: new chats in team workspaces are now visible to the team by default, so teams that relied on chats being private by default must update this setting to Private.

Adds listMessages tool to the v0 MCP server for reading a chat's full message history, and resolveTask tool for answering plan approvals, questions, permission requests, and integration prompts programmatically. The v0 MCP server now also returns scope-aware chat URLs alongside tool responses.

Enforces team Vercel deployment policies in v0's deploy button and GitHub import flow, hiding disallowed repositories and blocking production deploys the team forbids.

Team owners can now set a team default design system, including Design Systems 2.0 skills and built-in examples, and choose team or personal scope when saving from the save card.

The Restrict Memories and Skills setting is now available on any paid team plan instead of Enterprise only, and team members with v0 edit access can now manage team skills and memories without requiring a Vercel write role.

Adds crush login openai (also aliased as crush login chatgpt) to authenticate with a ChatGPT subscription via OAuth, unlocking subscription-granted models without a separate API key.⁠︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄⁠ crush logout openai (also crush logout chatgpt) removes the stored OAuth credentials.

$ crush login openai

Adds a --reasoning-effort flag to crush run for non-interactive/headless use, accepting values like max to control model reasoning depth — useful in CI pipelines or agent orchestration.

$ crush run --model "hyper/glm-5.3" --reasoning-effort "max"

Adds OTEL_METRICS_INCLUDE_REPOSITORY to tag OpenTelemetry metrics and events with vcs.* repository attributes; commit events additionally get vcs.ref.head.* attributes when OTEL_LOG_TOOL_DETAILS is also set.⁠︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄⁠

$ export OTEL_METRICS_INCLUDE_REPOSITORY=1
export OTEL_LOG_TOOL_DETAILS=1
claude

Adds CLAUDE_CODE_WORKFLOW_MAX_CONCURRENT_AGENTS (range 1–256) to raise the Workflow tool's per-run concurrent agent limit for inference-bound fan-outs.

$ export CLAUDE_CODE_WORKFLOW_MAX_CONCURRENT_AGENTS=32
claude

Adds claude plugin eval to run a plugin's eval suite against Claude Code and produce scored, reproducible results in JSON and HTML report formats.

$ claude plugin eval --help
claude plugin eval

Adds /output-style [name] slash command to list and switch output styles, including over Remote Control and in cloud and other headless sessions.

Adds CLAUDE_CODE_GATEWAY_MODEL_DISCOVERY_TIMEOUT_MS to extend the LLM gateway /v1/models discovery timeout beyond the 3s default.

Adds an agent map in the VSCode extension — an 'N agents' footer pill opens a map of the session's sub-agents with per-agent cards, a Stop agent action, and read-only transcripts.

Adds a Hooks dialog to the VSCode command menu for viewing hooks and adding, editing, or removing them in user, project, and local settings; managed, plugin, and session hooks remain read-only.

Adds a Permission rules dialog that lists permission rules and adds or removes them in user, project, and local settings; startup-option, session-only, and managed rules remain read-only.

OpenHands now exposes its agent via OpenAI-compatible Chat Completions and Responses API endpoints, enabling it to be used from chat UIs, IDEs, voice platforms, and other OpenAI-style clients.⁠︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄⁠

Bundles GNU voice helpers and runtimes into Linux musl release archives, with ALSA plugin discovery and increased capture/playback buffering for PipeWire compatibility, and bundles a Windows voice runtime into portable ZIP packages, enabling voice support on Windows.⁠︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄⁠

Adds kirocrew secrets import to move plaintext credentials from .env into the encrypted vault, leaving a secret:// reference behind; it runs as a dry run unless --apply is passed.⁠︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄⁠

$ kirocrew secrets import --apply

Retires the whisper, mlx parakeet, and faster speech-to-text providers in favor of a single in-process local provider that downloads its own model on first use (a 148 MB base model by default; a stored turbo setting still works but downloads 1.6 GB), enabling dictation without installing an external binary, with live text appearing as you speak and filtering of silence hallucinations and caption boilerplate. kirocrew doctor now reports stored provider defaults so users can decide which to adopt after the consolidation.

Adds security_policy.json published from a URL so administrators can push one security policy to an entire fleet; hosts cache and refresh it without a restart, reject invalid documents, and fall back to the cached policy when the source is unavailable. A misspelled sandbox key in the file now fails validation, and a malformed publish section denies publishing instead of silently dropping restrictions.

Adds kirocrew update to install a new version into a signature-verified tree and switch to it atomically; on Windows, 'Restart & Update' shows installer progress and relaunches the new build.

kirocrew chat now displays permission prompts so users can answer approval requests directly instead of waiting silently, and approval controls let users approve or reject all waiting tool calls at once, or reject one call while continuing to review the rest; long shell commands show a readable summary with the full command available on hover.

MCP server health view now shows a consecutive-failure count with one-click reset; remote OAuth servers can be connected from the MCP Servers page; and enterprise Kiro accounts honor administrator-managed MCP registry controls, including version pins.

Adds phone access: one action enables trusted mobile access, restarts the Gateway, publishes through Tailscale, and shows a sign-in QR code; phone sessions survive Gateway restarts and updates.

Adds the AWS Control app, a single surface to review account health, browse a versioned S3-backed drive, manage access, inspect billing, run cloud backups, and restore snapshots by replacing or merging components with a rollback ledger.

kirocrew snapshot --to s3://... and the --aws-profile fetch path with s3:// are no longer available; cloud backups now go through the new AWS Control app instead.

Durable always-allow grants no longer cover structured non-shell tools, and commands that look like help or version checks no longer count as approval; app trust is now tied to the approved repository, so legacy grants that cannot be matched to a repository will prompt for re-consent and some commands may ask for approval again.

Adds Ephemeral chat modes accessible via the + New menu — Incognito (reads memory, writes none) and Temporary (neither reads nor writes memory).

Supports persistent session tabs above the transcript, openable with middle-click or modifier-click, showing live status per tab; pinned, running, and unread sessions stay always visible while dormant sessions fold behind a configurable threshold expander.

Moves Knowledge content into Agent Capabilities > Knowledge & instructions; the standalone Knowledge page is removed from the sidebar and old /knowledge links redirect there.

enable_turn_detection added to GradiumSTTService to delegate end-of-turn decisions to Gradium's server-side endpointing signal instead of the pipeline's VAD, tunable via eot_horizon_s, eot_threshold, and post_flush_cooldown_frames.⁠︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄⁠

stt = GradiumSTTService(
    enable_turn_detection=True,
    eot_horizon_s=0.8,
    eot_threshold=0.6,
    post_flush_cooldown_frames=3,
)

SpeechmaticsSTTService now targets Speechmatics Agent STT (/v2/agent) via the speechmatics-agent-stt SDK, replacing speechmatics-voice[smart] in the speechmatics extra, with a new model setting defaulting to linden-1 and enable_partials replacing include_partials. Default turn_detection_mode is now TurnDetectionMode.VAD (pass TurnDetectionMode.EXTERNAL to drive turns from Pipecat's own VAD as before), and the service gains automatic reconnection with exponential backoff after dropped connections or recoverable server errors, with permanent-error reporting for rejected credentials or exhausted retries. Removed: SpeakerFocusMode, SpeakerFocusConfig, UpdateParams, update_params(), and the Settings/InputParams fields focus_speakers, ignore_speakers, focus_mode, speaker_passive_format, max_delay, end_of_utterance_silence_trigger, end_of_utterance_max_delay, split_sentences, include_results, and extra_params, plus TurnDetectionMode.FIXED, TurnDetectionMode.ADAPTIVE, and TurnDetectionMode.SMART_TURN; OperatingPoint is replaced by Model.

The openai dependency is widened to >=1.74.0,<4 to support the openai 3 SDK, which uses httpx2 instead of httpx for HTTP and verifies TLS against the OS trust store rather than certifi. Container images without system CA certificates and TLS-inspecting proxy environments may need SSL_CERT_FILE or SSL_CERT_DIR set; a Timeout passed to OpenAITTSService or Whisper-based STT services must come from httpx2 on openai 3, or httpx on older versions. Pin openai<3 to stay on the previous HTTP stack.

max_buffer_delay_ms added to SmallestTTSService to control the server-side buffering window for Smallest AI's continuation API, which joins text fragments within the same LLM turn under a shared context_id for unbroken prosody.

tts = SmallestTTSService(
    max_buffer_delay_ms=200,
)

The anthropic dependency is widened to >=0.49.0,<2 to support the anthropic 1 SDK; AnthropicLLMService now routes temperature, top_k, and top_p through extra_body. If a Bedrock client is passed, anthropic 1 requires an explicit region via AsyncAnthropicBedrock(aws_region=...) or the AWS_REGION environment variable, where it previously defaulted to us-east-1.

The pipecat eval suite live dashboard now shows pass rate for in-progress repeated (bot, scenario) rows and replaces the yellow middle band with green (all passed) / red (one failed) colouring. The recording line in pipecat eval suite settings reports which runs will actually record, e.g. on (3 of 6 runs; text mode skipped) or off (all runs text mode); pipecat eval run -a prints the same line.

DeepSeekLLMAdapter supplies reasoning_content on assistant messages when tool calls are in the conversation, fixing requests in thinking mode. DeepSeekLLMService now defaults thinking to disabled; pass thinking=DeepSeekLLMService.ThinkingConfig(type='enabled') to enable it or thinking=None to use DeepSeek's own default.

LiveKitParams.audio_out_queue_size_ms configures the outgoing rtc.AudioSource buffer size, defaulting to LiveKit's 1000 ms.

params = LiveKitParams(
    audio_out_queue_size_ms=2000,
)

Adds the capabilities parameter to Agent (and AgentSpec) for composing reusable units of agent behavior — tools, lifecycle hooks, instructions, model settings, and model selection — in a single import.⁠︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄⁠ The Capability class declaratively bundles instructions, function tools, and toolsets without subclassing, using decorators like @refunds.tool_plain to attach tools; defer_loading=True collapses a bundle to a catalog entry until the model loads it. AbstractCapability supports subclassing for behavior beyond instructions/tools/toolsets, CapabilityEvent (with a namespace argument and ctx.emit()) provides typed event publication, and the Toolset convenience class wraps an AbstractToolset as an authoring primitive.

from pydantic_ai import Agent
from pydantic_ai.capabilities import Thinking, WebSearch

agent = Agent(
    'anthropic:claude-fable-5',
    instructions='You are a research assistant. Be thorough and cite sources.',
    capabilities=[
        Thinking(effort='high'),
        WebSearch(local='duckduckgo'),
    ],
)

from pydantic_ai import Agent
from pydantic_ai.capabilities import Capability

refunds = Capability(
    id='refunds',
    description='Use for refund eligibility and refund status.',
    instructions='Always confirm the order ID before issuing a refund.',
)

@refunds.tool_plain
def refund_status(order_id: str) -> str:
    """Look up the refund status for an order."""
    return f'Order {order_id}: refund issued on 2026-05-01.'

agent = Agent('openai:gpt-5.6-sol', capabilities=[refunds])

from dataclasses import dataclass
from typing import Any
from pydantic_ai import CapabilityEvent, RunContext
from pydantic_ai.capabilities import AbstractCapability
from pydantic_ai.toolsets import AgentToolset, FunctionToolset

WORKSPACE = 'workspace'

@dataclass(kw_only=True)
class FileWriteEvent(CapabilityEvent, namespace=WORKSPACE):
    path: str
    bytes_written: int

workspace = FunctionToolset()

@workspace.tool
async def write_file(ctx: RunContext[Any], path: str, content: str) -> str:
    await ctx.emit(FileWriteEvent(path=path, bytes_written=len(content)))
    return f'Wrote {path}'

StepPersistence saves, restores, resumes via continue_run, and forks via fork_run runs, with file, SQLite, and Mongo backends.

Adds Thinking for provider-adaptive extended thinking at configurable effort; WebSearch for provider-native search with a local fallback (e.g. local='duckduckgo'); WebFetch for fetching and reading URLs, native or local; XSearch for searching X with a subagent fallback on non-xAI providers; MCP to connect any MCP server's tools with opt-in provider-native connectors; ImageGeneration for generating and editing images, provider-native where supported with a direct image-model fallback; and NativeTool to register any provider-native tool with the agent.

Adds ToolSearch for loading tool definitions on demand instead of carrying all definitions in every prompt; ToolApproval for flagging tool calls that require human approval before execution; HandleDeferredToolCalls for programmatically resolving approval-deferred tool calls; PrepareTools / PrepareOutputTools for filtering or modifying tool definitions per step; PrefixTools to wrap another capability and prefix its tool names; IncludeToolReturnSchemas to include return type schemas in tool definitions sent to the model; SetToolMetadata to merge metadata key-value pairs onto selected tools; and ThreadExecutor for running sync tools on a shared thread pool.

Compaction (Harness) provides model-agnostic compaction strategies — tool-result clearing, sliding-window trimming, LLM summarization, and tiered — all window-relative with live usage reporting.

Adds Planning for model-owned task plans with a cache-safe live reminder; Subagents for delegating self-contained tasks to named child agents; DynamicWorkflow for model-orchestrated sub-agents with fan-out, chain, and vote patterns in a single tool call, enforced by hard max_agent_calls budgets; and Advisor for letting an executor consult a stronger model mid-run.

CodeMode lets the model write one Python script calling many tools inside a Monty sandbox, reducing round-trips and keeping intermediate results out of the context window.

Adds Memory providing a persistent, namespaced notebook with bounded prompt injection, on-demand search, and in-memory, file, or Postgres stores; and ConversationSearch for BM25 search over stored history including turns compaction dropped.

Adds SelectModel for static or per-step model selection via a callable; ResolveModelID for resolving custom application-specific model IDs via a callable; Hooks for decorator-based lifecycle hook registration; ProcessHistory to wrap a history processor; ProcessEventStream to forward agent stream events to a handler function; and RaiseContentFilterError to raise ContentFilterError whenever a model response has finish_reason='content_filter'.

Adds Instrumentation for OpenTelemetry GenAI spans covering every model and tool call; Compaction for provider-native context compaction on OpenAI and Anthropic; and DurableExecution for runs that survive restarts and failures on Temporal, DBOS, Prefect, Restate, Kitaru, and Airflow.

Adds engine= parameter to dspy.LM(...) accepting 'auto', 'litellm', 'lm15', or a custom engine object implementing complete(Request) -> Response, plus async_engine= for async calls, enabling custom backends without subclassing BaseLM.⁠︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄⁠ Also adds the dspy.lm15 module exporting Request, Response, Message, Config, and Usage types for constructing explicit typed LM calls, with response.text and response.message.parts for accessing results.

from dspy.lm15 import Message, Response, Usage
import dspy

class MyEngine:
    def complete(self, request):
        # call your own backend here
        text = my_model_server.generate(request.messages[-1].text)
        return Response(
            id=None,
            model=request.model,
            message=Message.assistant(text),
            finish_reason='stop',
            usage=Usage(),
        )

lm = dspy.LM('custom/my-model', engine=MyEngine())
dspy.configure(lm=lm)

import dspy
from dspy.lm15 import Config, Message, Request

lm = dspy.LM('openai/gpt-4o-mini')
response = lm(Request(
    model=lm.model,
    system='Be concise.',
    messages=(Message.user('Summarize zero-trust networking in one sentence.'),),
    config=Config(max_tokens=100),
))
print(response.text)

dspy.LMRequest, dspy.LMResponse, dspy.LMMessage, dspy.LMConfig, dspy.System, dspy.User, and dspy.Assistant are removed; importing dspy.core.types raises a migration error, and forward_contract='typed_lm' is rejected. The dspy.clients.openai_format module is also removed, and experimental=True no longer changes ordinary LM calls into typed responses. Migrate to dspy.lm15.Request, dspy.lm15.Response, dspy.lm15.Message, dspy.lm15.Config, Message.user(text), and Message.assistant(text); old pickles containing the removed 3.3 classes must be loaded and exported in their original environment before upgrading.

Adds dspy.LocalInterpreter as an interpreter_factory= option for dspy.RLM and Flex, running generated Python in a persistent local CPython subprocess with execution_timeout support, without requiring Deno.

import dspy

rlm = dspy.RLM(
    'question: str -> answer: int',
    interpreter_factory=dspy.LocalInterpreter,
)
result = rlm(question='What is 17 * 42?')
print(result.answer)

Adds await agent.acall(...) support to dspy.ReActV2, enabling async prediction, async tools, and async MCP tool execution with structured tool-call history preserving call IDs and tool results across turns.

dspy.ReActV2 rejects signatures with output fields named history or termination_reason; rename those outputs before upgrading. Calling an async tool synchronously from a running event loop raises a ValueError even with allow_tool_async_sync_conversion enabled; use await tool.acall(...) instead.

Adds code_proposer= parameter to dspy.GEPA, complementing the existing instruction_proposer=, allowing custom Flex code-generation constraints and domain guidance without monkeypatching the built-in proposer.

Native n answers now use separate sequential requests instead of a single provider-native multi-answer request, which can increase latency and bill input tokens more than once; use engine='litellm' to retain the previous behavior.

Adds bun scripts/cull-staged-attachments.ts (run from /app/server) to sweep unsent staged attachments older than one day, requiring only DATABASE_URL; accepts an optional retention-window argument to change the cutoff.⁠︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄⁠

$ DATABASE_URL=postgres://user:pass@host:5432/openbot bun scripts/cull-staged-attachments.ts 86400

Messages can now include up to eight file attachments: images (PNG, JPEG, GIF, WebP) up to 8 MiB and text files (plain text, Markdown, CSV, JSON) up to 1 MiB. Files are uploaded at staging time so sends are immediate and failures preserve the attachments.

Supports connecting to keyless endpoints — Ollama, vLLM, LM Studio, llama.cpp — by requiring only a base URL and model name when no API key applies.

Credentials (model keys, plan tokens, inter-service tokens) are now stored in the platform credential store — macOS login Keychain, Windows DPAPI, or an owner-only file on Linux — rather than in .env.

Setup now automatically installs a container engine (Podman or Docker) and a Compose implementation when neither is present, pinned to a tested digest and verified before execution.

Adds hermes update --check CLI command and 'Check for Updates…' / Settings → About → 'Check now' UI paths to bypass the 24-hour passive update-check cache.⁠︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄⁠

$ hermes update --check

Adds agent.budget_warning_ratio config key to append a model-visible checkpoint notice after a configurable fraction of the iteration budget is consumed, with Kanban dispatcher workers defaulting to a 90% threshold.

Adds automatic point-in-time config backups to backups/config/config.yaml.<reason>.<timestamp> before hermes setup, hermes migrate, or on parse failure, keeping at most the newest five per reason.

Adds docker_snap_compat config key to drop --init and --security-opt no-new-privileges for snap-packaged Docker on Ubuntu/Azure hosts where AppArmor confinement would otherwise kill the container.

Adds terminal.env_passthrough config key to forward skill-declared variables to remote SSH sessions via OpenSSH SendEnv; provider credentials are never forwarded even if listed.

Adds /fast normal|fast|auto|cold slash command to switch Fast Mode priority processing for the current session, with a --persist flag to save the choice.

The agent can now sign in, pay, and fill addresses using credentials from 1Password, Bitwarden, or the local Hermes vault without exposing secrets to the model itself; two-factor codes are supplied from a saved authenticator key or prompted in the user's UI. Private git plugins can also now install using stored vault credentials.

Adds context_file_read_timeout config key (default unspecified seconds) to skip slow network-backed context files such as iCloud Drive, OneDrive, or NFS rather than stalling the system prompt load.

Adds a curated, SHA-pinned plugin catalog with CLI, admission CI, docs, and a dashboard view. Desktop now has a single Plugins page covering agent and desktop plugins, install, catalog, and per-commit pinning. Radio ships as an opt-in SDK plugin.

Adds /login to sign in to a Nous account directly from a chat session, which activates free Nous inference and connectors out of the box with one sign-in command.

Adds GIT_SSH_COMMAND environment variable support for internal Git operations, taking precedence over Hermes's default ssh -o BatchMode=yes for custom identity or transport commands.

Adds file_access_read_lines to AgentFileStore, moving the line-numbering contract onto the store itself; callers that previously handled line numbering outside the store must migrate to the new contract.⁠︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄⁠

Adds createAssistantCloudTraceExporter, createAssistantCloudSpanProcessor, assistantCloudTraceMetadata, and withAssistantCloudTraceMetadata in assistant-cloud/telemetry to send AI SDK GenAI spans to POST /v1/traces and merge server spans with client run reports into a single trace.⁠︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄⁠ Also adds a createRunReport builder in assistant-cloud to assemble run-report bodies carrying provider, outcome_type (aborted, disconnected, length, content_filter), error_code, error, message_id, first_token_ms, duration_ms, finish_reason, trace_id, environment, release, and tags from the telemetry config.

import { createAssistantCloudTraceExporter, createAssistantCloudSpanProcessor } from 'assistant-cloud/telemetry';

const exporter = createAssistantCloudTraceExporter({ cloud });
const processor = createAssistantCloudSpanProcessor(exporter);
// register processor with your OpenTelemetry SDK provider

Adds engagement-event batching to POST /v1/events covering sends, edits, stops, regenerates, copies, branch switches, suggestions, attachments, thread switches, speech, voice, and shown errors; opt out with telemetry.events: false.

const runtime = useCloudChat({
  cloud,
  telemetry: {
    events: false
  }
});

Adds logger and logLevel options to new Composio({...}): logger accepts any { error, warn, info, debug } sink (console, pino, winston, etc.) and logLevel accepts 'silent' | 'error' | 'warn' | 'info' | 'debug', overriding the COMPOSIO_LOG_LEVEL environment variable.⁠︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄⁠

import pino from 'pino';
import { Composio } from '@composio/core';

const logger = pino();
const composio = new Composio({
  apiKey: process.env.COMPOSIO_API_KEY,
  logger,
  logLevel: 'debug'
});

Adds composio.webhooks.subscriptions with list, get, set, update, delete, rotateSecret, and listEventTypes methods, and composio.webhooks.endpoints with list, get, create, replace, and update methods for full webhook lifecycle management.

Adds composio.toolkits.recommendScopes(toolkitSlug, { tools, ... }) and composio.toolkits.listGrantContexts(toolkitSlug) for OAuth scope recommendations (API-beta), letting callers request only the scopes a given tool set needs.

const scopes = await composio.toolkits.recommendScopes('github', {
  tools: ['GITHUB_CREATE_ISSUE', 'GITHUB_LIST_REPOS']
});
console.log(scopes);

Adds composio.connectedAccounts.revoke(), surfacing the API's 400/409 errors as ComposioConnectedAccountRevocationNotSupportedError and ComposioConnectedAccountNotRevokableError.

Adds composio.connectedAccounts.completeAuth({ userId, sessionUri }) to complete a deferred OAuth connection after callback verification.

Exports readResponseBodyWithLimit and MAX_URL_UPLOAD_SIZE_BYTES so downstream packages can apply the SDK's 100 MiB cap when downloading from user-supplied URLs.

Adds composio.logs.search() and composio.logs.get() for querying tool-execution logs.

connectedAccounts.refresh() now ignores the validateCredentials option and logs a warning when it is set, because the upstream API removed validate_credentials from the connected-account refresh endpoint.

The default carve strength in carve.mjs was raised from 0.25 to 0.8, and the level-envelope release was extended from 1.6s to 2.4s, keeping narration clear over background music without the bed dropping out at every sentence break.⁠︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄⁠

Adds opt-in 2D block scaling for MXFP8 weights via MXFP8BlockScaling(enable_2d_quantization=True), giving finer-grained quantization granularity during training.⁠︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄⁠

import transformer_engine.pytorch as te
from transformer_engine.common.recipe import MXFP8BlockScaling

recipe = MXFP8BlockScaling(enable_2d_quantization=True)

model = te.Linear(1024, 4096)
with te.autocast(enabled=True, recipe=recipe):
    out = model(inp)

The NCCL-EP Python API changed to support eager dispatch and drop-on-overflow: pass num_topk to ep_bootstrap, update positional ep_bootstrap and EpBuffer calls, and replace EpBuffer.token_counts with EpBuffer.tokens_per_expert.

Adds an overwrite_input option to parallel_cross_entropy to reduce memory usage by reusing input storage in place, and further optimizes the function's performance and memory use.

import transformer_engine.pytorch as te

loss = te.parallel_cross_entropy(logits, labels, overwrite_input=True)