The AI Toolchain — issue 013, September 1, 2026

Adds openai/gpt-oss-20b and openai/gpt-oss-120b via POST https://api.groq.com/openai/v1/chat/completions. Both are MoE reasoning models with 131K token context and 32K max output tokens, and both support built-in browser search, code execution, and structured output. The 20b model uses 32 experts at ~1000+ TPS; the larger 120b model uses 128 experts at ~500+ TPS for higher-accuracy tasks.

$ 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"}
    ]
  }'

$ 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-120b",
    "messages": [
      {"role": "user", "content": "Summarise the latest OWASP Top 10 risks in Spanish"}
    ]
  }'

Adds auto as an accepted value for the quality parameter on grok-imagine-image-2.0, which dynamically selects low for generation and medium for editing, with billing reflecting the quality actually served. The default value of quality when the parameter is omitted has changed from medium to auto, so existing requests that omit quality will now receive low-quality output for generation (previously medium) — pass low or medium explicitly to pin a specific quality.

Increases the maximum number of source images accepted per image-editing request from 3 to 5 (via repeated image[] fields). Adds 21:9 (cinematic widescreen) and 5:2 (wide banners) as accepted aspect ratio values for both image generation and editing.

$ curl https://api.x.ai/v1/images/generations \
  -H 'Authorization: Bearer <YOUR_API_KEY>' \
  -H 'Content-Type: application/json' \
  -d '{"model": "grok-imagine-image-2.0", "prompt": "futuristic cityscape", "aspect_ratio": "21:9"}'

$ curl https://api.x.ai/v1/images/edits \
  -H 'Authorization: Bearer <YOUR_API_KEY>' \
  -F 'model=grok-imagine-image-2.0' \
  -F 'prompt=merge all styles into one cohesive scene' \
  -F 'image[][email protected]' \
  -F 'image[][email protected]' \
  -F 'image[][email protected]' \
  -F 'image[][email protected]' \
  -F 'image[][email protected]'

Adds the studio_frame WebMCP tool giving agents visibility into the current Studio frame for inspection and context, plus additional WebMCP support letting agents drive Studio's selection and playhead position, edit text and styles within compositions (guarded), and author motion within compositions.

Adds the hw-write-title block and control surfaces for the handwritten family to the Registry, cataloged as the 'hw write-on wave' entry.

Adds experimental build presets, allowing a build to be driven from a file via --build-presets-file instead of a long command line, e.g. python build.py --build-presets-file my_build_presets.json.

$ python build.py --build-presets-file my_build_presets.json

Adds a log callback option to the tritonserver C and Python APIs and to the common Logger, letting an embedding application route Triton log records into its own logging stack instead of a file or stream.

Improves model-readiness reporting in TRITONSERVER_ServerModelIsReady — non-availability errors are now returned and unresolved models correctly report ready=false.

Serverless endpoints can now select a Hugging Face model ID at configuration time, which triggers locality-aware scheduling that prefers hosts or network volumes already holding the model's bytes. Caching is tiered: host-local disk first, then a datacenter-scoped MooseFS network volume, then remote origin, with additional workers deferred until the shared cache copy is verified before scaling out. Explicit model version pinning via model@version makes which artifact version is serving traffic deterministic, and the cached files can be loaded offline from /runpod-volume/huggingface-cache/hub/ without a network download at startup.

import os
from pathlib import Path
from transformers import AutoModelForCausalLM, AutoTokenizer

org, name = "mistralai", "Mistral-7B-Instruct-v0.2"
cache_root = Path("/runpod-volume/huggingface-cache/hub")
snap_dir = sorted((cache_root / f"models--{org}--{name}" / "snapshots").iterdir())[-1]

tokenizer = AutoTokenizer.from_pretrained(str(snap_dir), local_files_only=True)
model = AutoModelForCausalLM.from_pretrained(str(snap_dir), local_files_only=True)

New tg batches command group manages batch inference jobs: tg batches submit uploads a local JSONL file or existing file ID and creates a job against chat.completions, audio.transcriptions, or audio.translations; tg batches list, tg batches retrieve, and tg batches cancel (with ls and get aliases) manage the job lifecycle; tg batches download streams results to stdout or writes output and error files to disk with --output.

tg fine-tuning model-limits (alias tg ft model-limits) queries GET /fine-tunes/models/limits for a base model's capability flags and hyperparameter bounds, with --json for the full response body. tg ft download-tokenized-dataset <ft_id> downloads the tokenized dataset a job trained on for auditing; this is now surfaced in the tokenized_dataset_upload_complete event, visible in the console Events tab and via GET /fine-tunes/{id}/events.

A new fully automatic confirmation policy enables end-to-end unattended repair with per-fault scoping across fault groups (Migrate to new host, Reprovision, VM reboot) and job interruption controls (Wait for idle, Grace period, Maximum wait, Do not interrupt running jobs). Automatically approved repairs record Auto-Approved in the Reviewed by field.

New GET /billing/usage endpoint (beta) returns organization-wide usage and cost line items, filterable by month, and is enabled per organization.

New tg beta endpoints events lists a dedicated endpoint's audit and lifecycle events — replica scaling, traffic shifts, status changes, and pauses — from the terminal.

A new progress_callback parameter on client.files.upload() in the Python SDK receives upload progress events, and tg files upload and tg files check CLI commands now show a progress bar in interactive terminals.

from together import Together

client = Together()

def on_progress(event):
    print(f"Uploaded: {event}")

client.files.upload(file="dataset.jsonl", progress_callback=on_progress)

A unified one-step project deletion automatically disconnects custom domains, unpublishes the live site, deletes the Bolt database, and removes project files and chat history, removing the need for separate StackBlitz cleanup. It offers a pre-deletion export so you can keep a local copy, and reports any resources Bolt cannot clean up itself (such as an externally managed Supabase database or DNS records at another provider) for manual handling. In team projects, deletion is restricted to team Admins and the project Owner or Co-owners.

Bolt now lets you queue up to 20 prompts while it is still building, with the ability to edit, reorder, or delete queued prompts and pause/resume the queue at any time. Each queued prompt preserves the agent it was submitted with, and in shared projects the queue shows per-prompt collaborator avatars so it's visible who submitted each pending prompt.

Adds a /learn command that opens the Command Code learn hub directly from the CLI, without leaving the terminal.

$ /learn

Adds tui.disable_paste_burst as the preferred configuration key under the [tui] section, with precedence over the legacy top-level disable_paste_burst key when both are present.

[tui]
disable_paste_burst = true

The planning tool (update_plan) is now disabled by default; existing setups relying on it must explicitly set tools.update_plan.enabled = true to restore the behavior.

tools.update_plan.enabled = true

Exposes the complete upstream response.usage object in ResponseUsageMetadata.metadata via rawResponse/completed notifications, alongside the existing amount field, with updated JSON and TypeScript schemas.

The Cline provider model catalog now refreshes from the live feed so newly released models appear without waiting for an app update. This release adds new providers TokenGo and Volcengine Ark and updates model lists, pricing, and resolved default models for roughly 36 providers including Hugging Face, Mistral, OpenRouter, Together, NanoGPT, Requesty, Baseten, Cloudflare Workers AI, and DigitalOcean. If you use one of these providers without pinning a model, the resolved default model will change after upgrading.

Classifies provider HTTP 401/403 responses as authentication errors, making a bad or missing API key distinguishable from a provider outage.

Streams run_commands output live to the desktop UI instead of buffering until completion.

Adds option ui exit-banner to .crushrc and options.tui.exit_banner to crush.json, supporting values compact, none, and default to control exit banner verbosity, useful for headless or low-context terminal workflows.

{
  "options": {
    "tui": {
      "exit_banner": "compact"
    }
  }
}

option ui exit-banner none

Adds a scrollable, fixed-pitch turn rail to the chat UI that lets practitioners jump to any turn in a long session and settles the view after paging completes. Adds loadThrough deep history paging to the session controller for navigating arbitrarily long session histories, whole-log turn outline projection with settled-response previews at card budgets for fast session scanning, and an identity-gated change feed to session projection for more precise incremental UI updates.

read_image in tool-fs now accepts extension-less attachment paths, so image files without a file extension can be attached to agent turns.

The SQLite persistence backend has been removed from dsh-session (refactor(session)!: remove SQLite persistence backend); any working setup relying on SQLite-backed session storage will break on upgrade.

Session search now spans every connected gateway, interleaving local and remote results — queries like 4411, /pull/4411, or owner/repo#4411 all find the same session — and sessions can be filtered by tag and assigned any custom hex color. A session summary side-panel tab explains what each thread was trying to do and where it landed, showing token cost before you enable it; the context window is visible as a percentage and token count as it fills; earlier chats resume in the background so the first message of a resumed session sends immediately. Session hand-off can send a session with its full context to another Kiro Crew instance, an interrupted turn can be resumed from any idle session, queued messages can be reordered before they send, and a live wait countdown lets you end a wait early.

MCP servers are discoverable, probeable, and enableable directly from the dashboard. A Measure action assesses whether a server can safely share a process by comparing tool sets, storing the verdict and displaying each server's evidence tier and run mode in MCP Management, replacing the old global sharing switch with per-server connection pooling probes. Registry aliases let tools from two servers that share the same name (e.g. Linear, Vercel, and GitHub) both remain usable without collision. Per-agent tool sets let you assign MCP servers to particular agents, authenticated custom MCP servers let you supply request headers when adding a remote server instead of hand-editing a config file, and a Reload action relaunches the agent process in place so newly added MCP servers and config take effect while the conversation survives.

An opt-in OS-level sandbox confines kiro-cli subprocesses on Linux and macOS, backed by 137 built-in denied-command patterns, credential redaction, and a two-level governance ceiling stored outside the agent's read/write scope. kirocrew policy show prints the built-in denied-command rules grouped by category, and custom deny notes let a refusal from a deny pattern carry an explanatory note.

$ kirocrew policy show

Kiro Crew introduces secret://NAME syntax for MCP server environment references, resolved from an encrypted vault at spawn time so secrets never sit in on-disk config. A new Settings > Secrets page keeps vault values masked, never sends them to the browser, and lets specific agents be denied access via a denylist.

Bot integrations for Slack, Discord, Telegram, Microsoft Teams, Webex, WeCom, and WeChat all share the same agent memory and tool set. Three new channels are added: WhatsApp (link via QR code), iMessage (routed through Messages.app via a local macOS bridge, deny-by-default with an explicit allowlist), and Feishu (Lark); Teams, Telegram, and Webex reach feature parity with Slack, and Discord gains a nine-command slash menu with a model picker, runtime stats, and cron delivery. Telegram further gains a real command menu (type / for autocomplete, switch models with inline buttons, markdown tables render as tables) and attachment support for inbound images (vision), documents, and audio (transcribed on arrival).

An in-dashboard App Store launches with TypeScript and Python SDKs and six bundled apps including Auto Research, Code Review Sage, and Issue Radar, later joined by Personal Shopper (researches stores and recommends only when buying helps) and a Curated App Store Discover surface with editorial spotlights, themed collections, and category rails. Eight more opt-in apps follow: Spec Builder, Ops Mission Control, Auto-Improvement, Meetings (live transcription), Papyrus (LaTeX editor), Mochi, Crew Companion, and PPTX Maker (generates real .pptx files from chat descriptions); Code Review Sage separately gains support for GitHub Enterprise Server hosts.

kirocrew tailnet up publishes the dashboard on a Tailscale network; kirocrew cloud logout ends the current cloud sign-in session; and kirocrew setup --slack requests Slack credentials on demand so kirocrew setup can finish on the dashboard without requiring Slack tokens upfront.

$ kirocrew tailnet up

$ kirocrew setup
# Later, when you want Slack integration:
kirocrew setup --slack

Computer Use via UI Automation is no longer macOS-only — Kiro Crew can now read and drive native Windows applications, with the Windows agent tree running under a Job-object process and memory ceiling mirroring the existing Linux control. Computer Use itself lets the agent operate native apps through the accessibility layer (press buttons, fill fields, scroll, drag), is off by default, writes every call to an audit log, and is enabled via Settings > Computer Use.

kirocrew run TASK.md hands the agent a spec for autonomous decomposition, execution, testing, and retry over 10+ hour runs, with disk checkpoints for crash recovery.

$ kirocrew run TASK.md

Telegram is now single-account only; the bot token is configured via telegram.bot_token, only one bot token is served per install, and the existing multi-account map is no longer read.

telegram:
  bot_token: "YOUR_BOT_TOKEN"

kirocrew spawn run splits work across parallel sub-agents for concurrent execution; Crew Mode lets the agent dispatch topics to parallel sub-sessions that return answers independently so multiple work threads advance simultaneously; and sub-agents are now steerable with queued follow-ups, scoped to task-specific context, with completions reported as cards in chat.

$ kirocrew spawn run

Boot uses approximately 875 MB less memory because the embedding model now loads on first real use instead of at startup; kirocrew CLI startup drops from 1.3 s / 112 MB to 0.5 s / 54 MB; and sandboxed spawns are approximately 1.45 seconds faster each.

Adds live streaming speech-to-text, voice memo transcription on arrival, and local Piper text-to-speech with no cloud round-trip; on-device Apple speech-to-text voice input follows with live streaming, microphone switching mid-recording, and dictation landing at the cursor; push-to-talk lets you hold a key to dictate or tap to latch it on, with key, mode, and a live test strip configurable in Settings; and a local Parakeet speech-to-text provider running on Apple Silicon (faster than Whisper) is added, with Escape now stopping the assistant from speaking.

Issue Radar assigns autonomous workers to claimed issues, each in its own worktree with a public claim ledger and a pull request; it now also covers Azure DevOps repositories and work items alongside GitHub and GitLab, adding dependency edges, an unblocked-dependency signal, and a Focus Tree graph.

Browser automation was introduced via Playwright for navigation, form filling, and screenshots, then exposed through a Persistent Browser Mode Settings toggle that streams a live view into the dashboard's Browser panel, and finally made agent-driven so the agent directly navigates, clicks, types, and screenshots inside the panel (with native desktop Computer Use also offered on macOS).

Native Linux ARM64 build lands and Windows becomes a first-class target alongside macOS and Linux x86; a new --managed-python installer flag provisions a pinned interpreter on hosts whose system Python is too old.

Artifacts are versioned documents, code, and interactive widgets deployable as a webapp to an AWS account with a public HTTPS link and configurable TTL; screenshots and diagrams produced by the agent are also preserved as artifacts, with a gallery and detail page.

Knowledge search gains a source filter with source discovery, and the graph view adds a source dropdown, a physics-based layout, community clustering, and an adjustable depth control.

The dashboard transcript gains side-by-side diff rendering, per-file inline editing, and a project file tree in the side panel; file edits made by a tool now render as always-visible diff cards.

The terminal was promoted to an app-wide dock tab with a searchable, previewed font picker that detects local fonts; it then gained docking to bottom or right, opening in the session's own project directory with the preferred shell; and finally gained the ability to pop out into its own window, complete subcommands and flags (not just paths), and accept a configurable font.

Detects native MTP (Multi-Token Prediction) artifacts in supplemental weight shards, keeping speculative/cache settings explicit and model-safe. Adds separate adaptive MTP profiles for tool workloads, prototypes a proposal-only Qwen MTP head, adds sampled controls to the native MTP benchmark, defaults GLM native MTP to autoregressive with a measured-cost fallback of text MTP to AR, attributes MTP verifier acceleration per request, and gates GLM verifier slab fusions behind an opt-in flag.

Persists parsed tool turns before publishing terminals and reconstructs stable tool contracts across turns, improving reliability of tool-use sessions in multi-turn conversations. Drains terminalizing tool requests without aborting so in-flight tool calls complete cleanly on session teardown, holds tool terminals until cache persistence completes to keep native Qwen tool prompts stable across continuations, and adds a stable auto tool policy to agentic cache proof, modeling stable Responses instructions.

Adds an opt-in compact GLM MLA cache path, now advertised as the GLM family default, with amortized appends and active schema reported from runtime.

Adds agent.turn_liveness configuration block with timeout_s (default 600.0) and poll_s (default 15.0) to bound how long a turn may show zero observable progress — streaming tokens, tool heartbeats, and approval waits all count as progress — before Hermes force-recovers it. Invalid values (NaN, Inf, non-positive poll_s) log a warning and fall back to defaults instead of crashing startup; setting timeout_s to a non-positive value explicitly disables the watchdog.

▶

turn_liveness:
  timeout_s: 300.0  # fire after 5 min of zero progress
  poll_s: 10.0      # check every 10 seconds

Adds hermes peer CLI subcommand for bot-to-bot direct messaging between agents across profiles and gateways, with replies landing in each agent's durable Bot Chat. Includes peer run <bot> --idempotency-key <key> to launch a long-running bot task asynchronously and return a run_id immediately instead of blocking, peer status <bot> <run_id> to poll an in-progress run, and peer stop <bot> <run_id> to interrupt a specific run without affecting other turns; the --idempotency-key flag makes retries return the original run rather than spawning duplicate work.

$ hermes peer run spark --idempotency-key ticket-123 /tmp/long-task.txt

$ hermes peer status spark run_abc123

$ hermes peer stop spark run_abc123

$ hermes peer @coding-bot 'Here are the API surface findings from last night — please draft the integration sketch'

Adds browser.engine: lightpanda support in Browser Use mode — _resolve_backend_cdp() now reads the setting and spawns Lightpanda automatically when no higher-precedence backend is active. Also adds in-app browser automation: the agent can navigate, click, and read the desktop's built-in browser directly, with pages poppable to the system browser.

browser:
  engine: lightpanda

Adds live steering to delegate_task: list running child agents, send mid-flight course corrections, or stop a child early and retain its partial result. Also adds optional JSON-schema validation on delegate_task child outputs, per-delegation cost reporting in results, and raises defaults to 250 iterations and 10 concurrent children.

Adds a hermes:// deep-link scheme for installing MCP servers with explicit user confirmation, plus an MCP command-center dashboard with drag-in "paste anything" import, background health checks with re-auth nudges, and a fleet cost/usage overlay showing schema token estimates and 30-day usage per server.

Adds a continuity=true flag for cron jobs so each run's output is carried into the next, enabling deduplication across scheduled agent runs. Cron agents now load and update persistent memory and receive a durable notepad scratchpad; monitor-mode jobs skip the LLM when nothing changed. Cron output can also be routed into a bot's canonical Bot Chat so the bot responds to scheduled job results.

Adds six new built-in providers: Meta Model API (Muse Spark), CommandCode (GOAT/Pro/Max plans), Tencent TokenPlan, Nebius Token Factory, Ramp Router, and Actual Computer. Also expands the model catalog with GLM-5.3-Flash, qwen3.8-max, qwen3.8-flash, Gemini 3.7 Flash, MiniMax M3 free, and Nemotron 3.5 Lightning.

Adds /status CLI command showing reasoning mode, pending approvals, and context usage; /model picker with live filtering as you type; a Ctrl+P fuzzy command palette; and global emergency stop plus session pin/unpin controls to the desktop CLI.

failproofai audit inspects supported agent history locally and opens findings at http://localhost:8020/audit, keeping all analysis on-machine; failproofai audit --scheduled runs headless local scans with [audit] auto off by default because the scan reads transcript contents. failproofai audit --schedule [days] --email <address> puts the audit on a recurring timer (interval 1-90 days, default 7) and emails digests with counts and redacted examples only plus the machine name, entirely from the terminal; failproofai audit --no-schedule cancels the schedule without signing out, and failproofai audit --status reports scheduling state, report destination, daemon health and next scan time, now also surfacing collector-reported delivery failures such as revoked or expired keys. A /settings dashboard page, reached via the gear icon in the header, configures scheduled audits from the UI and is server-rendered from config; it shares the same updateConfig path and session file as the CLI so changes from either surface are immediately consistent. Audit files now reside under ~/.failproofai/audit/, migrated automatically on first run, with the session file kept at 0600 mode.

$ failproofai audit --schedule 7 --email [email protected]

$ failproofai audit --status

$ failproofai audit --no-schedule

failproofai config --connect <url> --token <key> enrols a machine in FailproofAI Cloud in one step, sharing one credential and URL for both policy pull and event ingest. failproofai config --disconnect fully severs Cloud enrolment: the daemon reads mode: "oss" and goes silent, clearing the active manifest so no deployment policy keeps enforcing. failproofai config --pause / --resume gives time-boxed suspension of enforcement for one session, with a hard 8-hour ceiling on any unbroken stretch. failproofai config --token <machine-key> supports non-interactive Cloud setup, and setting the FAILPROOFAI_CLOUD_TOKEN environment variable then running failproofai config keeps the key out of command history. On Windows, failproofai config now exits 1 with an explanatory message before writing anything, rather than completing setup with a weaker enforcement guarantee.

$ export FAILPROOFAI_CLOUD_TOKEN=<machine-key>
failproofai config

failproofai update completes the upgrade npm cannot do: it runs pending home migrations, installs the matching failproofaid binary, and restarts the service — running npm install -g failproofai@latest alone is insufficient, since ~/.failproofai/ and the daemon binary are not updated without it. failproofai migrate [--dry-run] runs the home migration alone or previews the plan without making changes, recording applied steps in migrations/applied.json and backing up irreplaceable files to ~/.failproofai/migrations/backup-layout<n>/ first. failproofai uninstall [--purge] is the sanctioned removal path, removing hook entries in every CLI and the root-owned unit, and optionally ~/.failproofai. failproofai backfill [--since 30d] re-sends history the collector has already read past, useful after re-enrolment or a cleared dashboard. failproofai harness add-path registers extra capture paths per harness for homes and gateways that live off the default roots.

$ failproofai migrate --dry-run

$ failproofai backfill --since 30d

Adds a Recommended setup path in failproofai config that auto-detects installed CLIs and selects a named 15-policy set (including block-rm-rf, block-force-push, and block-secrets-write); it unions with existing enabled policies so it cannot reduce existing protection.

A background daemon (failproofaid) is installed as a systemd unit at /etc/systemd/system/failproofaid@<user>.service on Linux or a launchd LaunchDaemon on macOS; on a configured machine, if the daemon is unreachable, enforcement is denied rather than falling back to in-process evaluation.

Adds live-hook enforcement on twelve agent CLIs: Claude Code, Codex, Copilot CLI, Cursor, OpenCode, Pi, Hermes, OpenClaw, Factory (droid), Devin, Antigravity (agy), and Goose, each verified live against that CLI's own hook contract and a named version. VS Code Copilot Chat agent mode gains enforcement for free by loading the same .github/hooks/*.json and ~/.claude/settings.json files already written by the copilot and claude installs, and documentation now covers enforcement differences across all twelve harnesses.

Machines that had audit.auto: true set under v1.0.0 continue scanning locally on upgrade but will not send email digests until explicitly opted in again, because audit.auto no longer implies upload consent. Run failproofai audit --schedule <days> --email <address> to re-enable digests.

Promotes policies as the main CLI noun; use failproofai policies add <pack> to explicitly choose which policy packs run.

failproofai publish now verifies every bundled source against the named release commit, including imported helpers, ignored files, renamed files, and symlinked paths. Publishing to an existing private repository is refused by default, preventing installation of packs that cannot fetch private release assets.

The always-on block-failproofai-commands guard now catches shell globs, interpreters, variables, loops, pipes, and agent-native Write, Edit, and NotebookEdit operations targeting ~/.failproofai.

A new endpoint, POST /runs/rules/validate, lets you test a multi-turn thread evaluator against a real conversation before saving it, by passing a test_thread_id, session_id, and an evaluator object with type: thread to confirm scoring logic works end-to-end.

$ 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>", "evaluator": {"type": "thread", "..." : "..." }}'

Legacy dataset comparison helpers are removed from the public OpenAPI spec and generated SDKs; existing HTTP routes continue to work only for LangSmith UI clients.