Source-led briefs

AI & Open Source Insights

A concise brief on the AI, software development, and open-source stories worth tracking. I read the sources and write each brief myself — the same judgment clients get on consulting engagements.

Briefing desk

JingLabs signal queue

Brief
01

Scan source material

02

Extract what changed

03

Add operator judgment

04

Publish concise brief

Week of 16 November 2026

Agent frameworks spent the week moving permission, verification and budget enforcement into the harness layer, while continuing to repair controls that had been configured and were not actually in force.

This week's pattern

The week’s releases converge on one place: the harness that sits between the model and the tools. Pydantic AI 2.71.0 added `PermissionRule`, which allows, asks about or denies tool calls and shell commands by rule, `RequireVerification`, which sends a coding agent back to its checks when it tries to finish after an unverified edit, `ReportRemainingBudget` and `WrapUpAtLimits`, which ends a run with a final answer instead of raising `UsageLimitExceeded`, and `Shell(secret_env=)`, which masks injected secrets in what the tools return. The same release added `ToolBridge`, which keeps the tool list fixed behind `tool_search`, `tool_describe` and `tool_call` so the prompt cache holds for large or changing tool sets. These are controls expressed as capabilities rather than prompt instructions, which is the first time most of them can be stated in a contract and then tested.

The second thread is the one that ran all week: a control that was switched on and did not apply. The OpenAI Agents SDK for Python 0.25.0 spent most of its changelog on approval decisions and guardrail results that did not survive a resume, Pydantic AI 2.70.0 carried two high-severity advisories in which a few hundred kilobytes of ordinary tool output could block the event loop for tens of seconds to minutes, and Claude Code 2.1.327 made `/status` list ignored permission settings and hook matchers that never match. Claude Code 2.1.328 then changed which hooks fire at all — managed `PostToolUse` hooks no longer run for calls refused before they ran, and Code Mode no longer runs `UserPromptSubmit` hooks on script output, so redaction must move to a `PostToolUse` hook with `updatedToolOutput`. The week’s operational outlier is LiteLLM 1.110.0, which shipped thirty-two entries marked breaking, several of them changing how spend is recorded, with no migration section on the release page.

Operator notes

What changed for implementation

  • Policy became a harness capability, not a prompt instructionPydantic AI 2.71.0 added `PermissionRule` for allowing, asking about or denying tool calls and shell commands by rule, `RequireVerification` to stop a coding agent finishing after an unverified edit, `Goal` for unattended runs, and `Shell(secret_env=)` to mask injected secrets in tool output. Earlier in the week the OpenAI Agents SDK 0.25.0 repaired nested approval decisions and guardrail results that were lost when a run resumed.
  • What a hook fires on can change in a patch releaseClaude Code 2.1.328 stops managed `PostToolUse` hooks firing for calls refused before they ran, and stops Code Mode running `UserPromptSubmit` hooks on script output, directing redaction to a `PostToolUse` hook with `updatedToolOutput`. It also warns in `/status` and `claude doctor` when an OpenTelemetry exporter has no endpoint and its data would likely be lost.
  • Cost and accounting moved under the same releasesLiteLLM 1.110.0 made the `SpendLogs` ledger the default accounting path, changed the identifier that streamed `/v1/responses` spend rows are stored under, and dropped the unused accounting event tables, across thirty-two breaking entries with no migration notes. Pydantic AI’s `ToolBridge` addresses the other side of the bill, by keeping a changing tool list from invalidating the prompt cache on every call.

JingLabs read

The useful move now is to re-express the guardrails you promised clients as harness capabilities rather than prompt text, because for the first time the frameworks give you rules and checks you can point at in a statement of work and verify in a test. Pair that with a deliberate re-read of your hook configuration after each upgrade: twice this week a control stopped applying without raising an error, and on the gateway side LiteLLM changed how spend is recorded without telling anyone how to reconcile it.

Weekly summaryHarness capabilitiesHooksCost control
19 November research scan

Papers & agent-ecosystem signals

Automated source pass — papers and releases only, no news
19 NovemberAgents

Pydantic AI 2.71.0 Moves Permission, Verification and Budget Control Into the Harness Itself — `PermissionRule` Allows, Asks About or Denies Tool Calls and Shell Commands by Rule, `RequireVerification` Sends a Coding Agent Back to Its Checks When It Tries to Finish After an Unverified Edit, `ReportRemainingBudget` Tells the Model How Much Usage and Spend Is Left and `WrapUpAtLimits` Ends a Run With a Final Answer Instead of `UsageLimitExceeded` — and Adds `ToolBridge`, Which Keeps the Tool List Fixed Behind `tool_search`, `tool_describe` and `tool_call` So the Prompt Cache Holds for Large or Changing Tool Sets

The release is tagged 2026-11-18 and was published on 19 November. Its feature list is dominated by new harness capabilities that sit between the model and the tools: `PermissionRule` in harness `Permissions` allows, asks about or denies tool calls and shell commands by rule (#13751); `RequireVerification` sends a coding agent back to run its checks when it tries to finish after an unverified edit (#13753); `Goal` keeps unattended runs working until a caller-defined completion check passes (#13733); `ReportRemainingBudget` tells the model how much of its usage limits and spend budgets is left (#13747); `WrapUpAtLimits` ends a run with a final answer instead of raising `UsageLimitExceeded` (#13670); `ReportStaleFiles` tells the model when workspace files it read have changed or been deleted (#13750); `Shell(secret_env=)` masks the secrets it injects in what the tools return (#13622); and `ReportToolErrors` sends unhandled tool exceptions back to the model as failed results instead of ending the run (#13745). Separately, `ToolBridge` keeps the tool list fixed behind `tool_search`, `tool_describe` and `tool_call` so the prompt cache holds for large or changing tool sets (#13744), and `ModelRouter` routes agent runs across models (#9046). The compatibility notes list thirteen items, among them the rename of `PeerNetwork` to `PeerConnection` (#13777), the deprecation of `api_key` on `StackOne` in favour of `auth` (#13735), and a run resumed from a deferred pause without `deferred_tool_results` pausing again if that step also ran other tools (#13051).

JingLabs read

Test `ToolBridge` first if your agent carries more than a handful of tools or an MCP server whose tool list changes: a tool list that shifts between turns invalidates the prompt cache on every call, and that is a recurring line on the invoice rather than a one-off. `PermissionRule` and `RequireVerification` are the two worth putting into a client engagement — a declarative deny rule is something you can show in a statement of work, and an agent that cannot declare a coding task finished until its checks have run removes the most common failure mode in unattended runs. Note the `PeerNetwork` rename before upgrading; it is a straightforward import change, but it breaks at build time.

pydantic-aipermissionsprompt-caching
Pydantic AI v2.71.0 release
19 NovemberTooling

Claude Code 2.1.328 Changes What Hooks Actually Fire — Managed `PostToolUse` Hooks No Longer Run for Calls Refused Before They Ran, and Code Mode No Longer Runs `UserPromptSubmit` Hooks on Script Output, So Redaction Must Move to a `PostToolUse` Hook With `updatedToolOutput` — While Adding `"onFailure": "block"` for `mcp_tool` Hooks and a `/status` and `claude doctor` Notice When an OpenTelemetry Exporter Has No Endpoint and Its Data Would Likely Be Lost

The 19 November release adds `"onFailure": "block"` for `mcp_tool` hooks, matching command and HTTP hooks, so a hook whose own call fails blocks the action it guards, and adds `CLAUDE_CODE_DISABLE_DEFERRED_TOOL_RESUME`, which lets a host stop `claude -p --resume` and `--continue` from running a tool call that a hook deferred. Two changes alter which hooks run at all: managed `PostToolUse` hooks no longer fire for calls refused before they ran, so there is no log entry, rewrite, block or stop at that point, and Code Mode no longer runs `UserPromptSubmit` hooks, managed ones included, on scripts' output — the release states that redacting that output now requires a `PostToolUse` hook with `updatedToolOutput`. Elsewhere, `/status` and `claude doctor` now warn when an OpenTelemetry exporter has no endpoint and its data would likely be lost, `deniedMcpServers` entries of the form `claude.ai <name>` now apply to that connector in cloud and self-hosted runner sessions too, `/code-review` on most models now reports only bugs and CLAUDE.md violations and marks each finding Important, Pre-existing or Nit, and a fix stops saving a scheduled task erasing the project's other saved tasks when the scheduled tasks file cannot be read.

JingLabs read

Re-read your hook configuration against this release rather than assuming an upgrade is neutral: if you redact secrets from Code Mode script output with a `UserPromptSubmit` hook, that hook stops running here and the redaction silently disappears, which is the same failure class — a control configured and no longer in force — that the past week of agent releases has been repairing. The OpenTelemetry notice is the quiet win for client work, because an exporter pointed at nothing produces exactly the same clean session as one that is working, and until now nothing said which you had.

claude-codehooksobservability
Claude Code v2.1.328 release
19 NovemberTooling

LiteLLM 1.110.0 Ships Thirty-Two Entries Marked Breaking With No Migration Section, Among Them the `SpendLogs` Ledger Becoming the Default Accounting Path, Streamed `/v1/responses` Spend Rows Saved Under the Encrypted `resp_` ID the Client Received, the Dropping of the Unused Accounting Event Tables, and the Proxy Ignoring Stored `general_settings` Keys That No Settings API Manages

The 18 November stable release marks thirty-two changelog entries with `!`, and the release page carries no migration or upgrade section — the only instruction on it is an optional `cosign verify` command for the Docker image. Several of the breaking items touch billing and accounting directly: `feat(accounting)!: make the SpendLogs ledger the default accounting path` (#49872), `fix(spend)!: save streamed /v1/responses spend rows under the encrypted resp_ id the client received` (#49493), `refactor(proxy)!: drop the unused accounting event tables` (#49923), and `fix(main)!: carry the full per-call price entry on the logging object instead of writing litellm.model_cost` (#49532). Others change proxy and provider behaviour: the proxy now ignores stored `general_settings` keys that no settings API manages (#48967), clients may only pick S3 buckets the admin allowed (#47496), one deployment's prompt-cache opt-in no longer reaches siblings on the same model (#49685), the Anthropic beta header allowlist is synced with what Anthropic, Vertex AI and Azure AI accept (#49409), and guardrails now check Anthropic and Responses request tools in `tool_permission` pre_call (#41011). A 1.109.x backport, v1.109.2, followed on 19 November.

JingLabs read

If you bill clients from LiteLLM's spend data, do not take this upgrade in one step: the accounting path, the identifier that streamed Responses rows are stored under, and the tables behind them all change in the same release, and the page offers no migration notes to check your reconciliation against. The conservative position for a European SMB deployment is to stay on the 1.108.x LTS line, which received 1.108.11 on 17 November, and to move to 1.110.x only after replaying a month of spend through a staging proxy and comparing totals.

litellmbreaking-changescost-tracking
LiteLLM v1.110.0 release
18 NovemberAgents

Pydantic AI 2.70.0 Carries the Fix for Two High-Severity Quadratic-Time Advisories in Its Harness — ANSI Stripping Under `ToolOutputLimits(strip_ansi=True)` and the Default `jwt` Secret-Redaction Pattern, Each of Which Let a Few Hundred Kilobytes of Attacker-Influenced Text Block the Event Loop for Tens of Seconds to Minutes — and Adds `StreamGuardrail`, Which Screens Each Streamed Text, Thinking and Tool-Call Part Before the Caller Sees It

The 17 November release opens with two high-severity advisories, both fixed in `pydantic-ai-harness` 0.70.0. GHSA-m4cr-m4qc-9hh3 states that with `strip_ansi=True` the `ToolOutputLimits` capability stripped ANSI escape sequences with a pattern that took time quadratic in the length of a line, so a tool result of a few hundred kilobytes containing many unterminated escape sequences could block the event loop for tens of seconds to minutes; GHSA-5m5q-5qj4-gx9h reports the same failure in the harness’s default-enabled `jwt` secret-redaction pattern, reached through `redact_secrets` or `secret_data()` on attacker-influenced text, and notes that the corrected pattern no longer matches a JWT whose header segment contains `-eyJ`. The release also adds `StreamGuardrail`, which screens each streamed text, thinking and tool-call part before the caller receives it, `PruneToolResults`, which lets the model replace a tool result it has received with a summary of it, and `RetryOnModelErrors`; flagged `PromptInjectionDefender` verdicts are now recorded as `prompt_injection flagged` spans.

JingLabs read

Patch this week if you run the harness, because both advisories are reached through ordinary tool output — a scraped page, a client log file, a command’s stderr — and the symptom is a stalled event loop rather than a crash, which in a single-process deployment presents as the whole service hanging. Do not treat the upgrade as fully transparent: the corrected `jwt` pattern no longer matches a token whose header segment contains `-eyJ`, so a secret of that shape now passes redaction unredacted.

pydantic-aidenial-of-serviceguardrails
Pydantic AI v2.70.0 release
18 NovemberAgents

OpenAI Agents SDK for Python 0.25.0 Is Mostly a Pass Over What Survives a Resume — Nested `ToolContext` Approval Decisions, Tool Guardrail Results After Approval, Nested Approval Checkpoints With Output Guardrails and a `RunState` Restore That Did Not Report a Missing Function Approval Owner — and It Writes `RunState` Schema 1.22, Which 0.24.0 Workers Reject, So Readers Must Be Upgraded Before Writers

The release is dated 17 November in its changelog and was published on 18 November. It lists two features — utilities for third-party session adapters (#5428) and removal of the beta Runloop sandbox provider (#5369) — against roughly forty fixes, most of them concerning state that did not survive suspension and resume: nested `ToolContext` approval decisions are preserved across resume (#5633), tool guardrail results are retained after approval and resume (#5643), nested approval checkpoints resume with output guardrails (#5629), a `RunState` restore now reports missing function approval owners (#5630), a tripped input guardrail skips the streamed model attempt that followed it (#5644), and completed input and output guardrails are reported when a tripwire fires (#5634, #6040). The page’s release-readiness notes set out the upgrade constraints: 0.25.0 writes `RunState` schema 1.22, which 0.24.0 workers reject, so readers are to be upgraded before writers; `OpenAIResponsesCompactionSession` now defaults to `gpt-6-luna` rather than `gpt-4.1`; MCP v2 accepts concurrent Streamable HTTP requests (#5641); and Runloop sessions and snapshots cannot be resumed once the provider is gone.

JingLabs read

If you run workers across more than one process, stage this rollout readers-first — a checkpoint schema older workers reject fails during the deploy window, not at build time — and re-test any human-in-the-loop path you have in production, because the shape repeated across these fixes is an approval or guardrail verdict that was correct when it was made and was lost when the run came back. Budget separately for the compaction default moving to a different model and for migrating off Runloop sandboxes, which this release strands.

openai-agents-sdkhuman-in-the-loopstate-migration
OpenAI Agents SDK for Python v0.25.0
18 NovemberTooling

Claude Code 2.1.327 Adds `claude mcp add-json <name> -` So a Server’s JSON and Any Token In It Are Read From stdin Rather Than the Command Line, Stops Project-Scope `claude mcp add` and `remove` Deleting Other Top-Level Keys Such as `$schema` From `.mcp.json`, and Turns `/status` Into a List of Broken Agent, Skill, Command and Output-Style Files, Keybinding Errors, an Unavailable Sandbox, Ignored Permission Settings and Hook Matchers That Never Match

The 17 November release adds `claude mcp add-json <name> -`, which reads a server’s JSON configuration from stdin so tokens stay off the command line, and which is not available from inside a Claude Code session. It fixes project-scope `claude mcp add` and `claude mcp remove` deleting other top-level keys in `.mcp.json`, such as `$schema`, and extends `/status` to report broken agent, skill, command and output-style files, keybinding errors, an unavailable sandbox, ignored permission settings and hook matchers that never match. The remainder is operational: `/install-github-app` asks before changing a repository and `/export` asks before overwriting a file, `claude -p` continues without model settings after ten seconds instead of hanging, startup no longer fails when `https_proxy` is a bare `host:port` with no terminal attached, and remote MCP servers reached by hostname over HTTPS are retried in the background for about a day after a long outage such as a dropped VPN.

JingLabs read

Move your provisioning scripts onto the stdin form now: an MCP server token passed as a command-line argument is visible in the process table and persists in shell history, and this is the first supported way to avoid both. The `/status` additions are the item with lasting value on client work — an ignored permission setting or a hook matcher that never matches is exactly the control a client believes is in force, and until this release nothing told you it was not.

claude-codemcpsecrets-handling
Claude Code v2.1.327 release
18 NovemberTooling

Langfuse 4.82.0 Fixes an SSRF in the GitHub Enterprise SSO Configuration and Pauses an LLM Connection After a Provider Returns 429 Instead of Retrying Inside the Call, While Reading Audit Logs From ClickHouse and Gating Legacy v3 Surfaces Behind Cutoff Switches

The 17 November release lists, among its fixes, “prevent SSRF attacks in GitHub Enterprise SSO configuration” and “pause an LLM connection after a provider 429 instead of retrying in-call” in the evaluation path. On the feature side it gates legacy v3 surfaces behind cutoff switches, reads audit logs from ClickHouse, and adds a Developer API key preset while renaming the Ingestion key type to Application. The 16 November 4.81.0 release immediately before it had added Google Vertex AI as a gateway provider, backfilled Postgres audit logs into ClickHouse, and added dataset item status filters and persisted custom session views.

JingLabs read

Deploy it if you self-host Langfuse for client work: an SSRF reachable from an SSO configuration form sits at instance level, and the operator who fills that field in is the account an attacker would most like to borrow. The 429 change is the quieter operational gain — an evaluation that retries inside the call against a rate-limited provider turns a transient limit into a long stall and extra spend, so it is worth checking against any eval run whose cost or duration you could not account for.

langfusessrfself-hosting
Langfuse v4.82.0 release
16 NovemberAgents

Browser Use 1.0.6 Makes BU 4.0 the Default Model Behind `Agent(task)` and `ChatBrowserUse()` in Place of bu-fast — Roughly Fifteen Times the Price With High Reasoning On by Default, Which the Release Notes Illustrate With a Short Test Run That Went From $0.0014 to $0.022 — and Opens the Browser Use Login Flow on a First Run That Carries No API Key

The 16 November release changes which model runs when no `llm` is passed: `Agent(task)` and `ChatBrowserUse()` now use BU 4.0 rather than bu-fast, with bu-4.0-mini suggested for simple tasks and bu-4.0-pro for the hardest ones (#6430). The notes state the cost consequence plainly — BU 4.0 is about fifteen times the price of bu-fast and runs high reasoning by default, and a short test run that previously cost $0.0014 cost $0.022 — and tell callers to pass `llm='bu-fast'` to keep the previous model and price. A first run without an API key now opens the Browser Use login and continues once approved, cloud browsers print a live-view link (#6425), and judge gotchas are kept grounded in what the run actually observed (#6418).

JingLabs read

If you run Browser Use unattended, pin `llm=` explicitly before taking this upgrade: a default-model change that multiplies per-run cost by roughly fifteen is a billing change arriving as a version bump, and nothing in your own code has to change for it to land. BU 4.0 is worth testing on the tasks that currently fail, but make that choice per workload rather than inheriting it from a default.

browser-usemodel-defaultscost-control
Browser Use 1.0.6 release
16 NovemberAgents

Browser Use 1.0.5 Turns On a Run Judge by Default That Scores Every Finished Run With the Caller's Own Model and Fills `result.judgement` With `success`, `failure_reason`, `description`, `prompt_injection_detected`, `bot_block_or_captcha_detected` and a List of Site Gotchas

The 14 November release adds a judge that runs after each task and populates `result.judgement` with `success`, `failure_reason`, `description`, `prompt_injection_detected`, `bot_block_or_captcha_detected` and `gotchas`, using the caller's own model (#6398). It is on by default: `judge_context=` passes your own success criteria, `judge=False` turns it off, the 0.x `use_judge` and `ground_truth` options work again, and the judge sees the run trace, the last screenshots and the final page unless `use_vision=False` (#6403). The notes report that across thirteen runs judged three times each, gotchas appeared in 15 of 15 verdicts where the site pushed back, up from 6 of 15 before, and in 2 of 24 verdicts on clean runs, with success verdicts unchanged.

JingLabs read

Test this deliberately rather than discovering it after an upgrade: `prompt_injection_detected` and `bot_block_or_captcha_detected` are the two fields worth routing into alerting, because a browser agent that quietly followed injected page text otherwise looks exactly like one that succeeded. It is an extra model call on every run, so set `judge=False` on high-volume paths where you already verify the outcome downstream.

browser-useevaluationprompt-injection
Browser Use 1.0.5 release
16 NovemberTooling

LangChain Core 1.8.1 Adds a `langsmith_gateway` Context Manager That Routes Models Built Inside It Through the LangSmith Gateway for the Current Thread or Task Only, Ignoring Explicit and Environment Base URLs and Keys So a Model Deserialised From Untrusted Input Cannot Redirect the Key or Bypass the Gateway, While langchain-groq 1.2.0, langchain-mistralai 1.2.0, langchain-xai 1.4.0 and langchain-deepseek 1.2.0 Move Onto the Shared Resolver and Drop Python 3.10

The 15 November core release ships `langsmith_gateway(api_key=...)`, a context manager scoped to the current thread or asyncio task, so gateway routing can be set per request rather than only through the `LANGSMITH_GATEWAY` environment variable (#41836). Inside the context the gateway key always wins, a base URL is kept only if it already points at the gateway host and any other base URL becomes `{gateway}/{provider_path}` — the stated intent being that an untrusted serialised model loaded inside the context cannot redirect the key or bypass the gateway — and the gateway is resolved when the model is constructed, not when it is invoked. Partner releases published the same day route `ChatGroq`, `ChatMistralAI`, `ChatXAI` and `ChatDeepSeek` through the same resolver with provider-specific paths and remove Python 3.10 from the partner packages (#41268), with the Groq integration also mapping context-length errors to `ContextOverflowError` and adding a `performance` service tier; routing itself stays off unless it is enabled.

JingLabs read

Two separate decisions arrive in one upgrade and should not be taken together. The per-context override is a genuine improvement if you already use the gateway — wrap model construction rather than invocation, or it will not take effect — but routing provider traffic through a hosted gateway puts a third party in the prompt path, which for a European SMB is a processor and transfer question to settle before the convenience argument; the Python 3.10 removal is the item to check against your deployment images this week.

langchaingateway-routingdata-residency
langchain-core 1.8.1 release
16 NovemberTooling

LiteLLM Backports to the 1.108.x LTS Line — Mixed Reasoning and Answer Content Is Preserved on the Responses API, `cache_control` Breakpoints Survive the Chat-to-Responses Bridge, Bedrock Converse Accepts `s3://` Media Sources, and Vertex AI Requests Now Carry Caller Identity Labels

The 14 November release is a backport onto the `lts/1.108.x` branch rather than a new feature line. It preserves mixed reasoning and answer content on the Responses API (#51356) and keeps `cache_control` breakpoints when a chat-completions request is bridged to Responses (#51796), adds `s3://` media sources to Bedrock Converse requests (#50401) and maps OpenAI vector-store search filters onto Bedrock (#51292). It also sends `reasoning_effort` to Foundry Kimi K3 while retaining its `reasoning_content` (#51748), supports Azure Foundry project and resource `/openai/v1` Responses base URLs (#51769), and attaches caller identity labels to Vertex AI requests (#51786).

JingLabs read

Take it if you are pinned to the LTS line: the `cache_control` fix is a cost fix rather than a correctness nicety, because a dropped breakpoint means paying full price for a prefix you believed was cached, with nothing in the response to say so. The Vertex caller identity labels are the second reason to move — per-caller attribution in Google's billing is the cheapest way to find which client workload is consuming your gateway budget.

litellmprompt-cachinglts
LiteLLM v1.108.9 release
15 NovemberTooling

Inspect AI 0.3.290 Stops vLLM and SGLang Server API Keys Being Written Into Eval Logs and Startup Errors and the `web_search()` Google Provider Logging Its API Key on a Connection Retry, Signs Calls to a Sentinel Sidecar Instead of Sending the Eval's Own Token, Scopes a Sandboxed Agent Bridge to the Identity Whose Sandbox It Runs In, and Stops a Bridged Agent Making a Further Model Call After a Limit Has Already Been Reached

The 14 November release of the UK AI Security Institute's evaluation framework carries eleven features and twenty-nine fixes, three of which concern credentials leaving the evaluation. vLLM and SGLang server API keys are no longer written to logs or startup errors, the `web_search()` Google provider no longer logs its API key when it retries a connection, and calls to a sentinel sidecar are now signed rather than carrying the eval's own token; a sandbox agent bridge running inside a sandbox identity scope now serves only that scope's user. A second group bounds work after a limit is hit: a bridged agent's host tools make no model call once a limit has been reached, and neither do its queued requests or native compactions, while Anthropic long requests no longer retry forever on the ten-minute read timeout and `eval()` now raises an error instead of silently running a different task registered under the same name. The release also adds `active_model_event_id()` for the in-flight model call attempt, keeps one message ID through the agent bridge and the log with tool events recording which message proposed them, excludes excluded epochs from epoch reduction with `excluded` and `zeroed` score reasons, and adds Gemini 4 Carbon and Hydrogen, Muse Ember 1.0 and Wonder 1.0, and Mistral Large 4.

JingLabs read

Upgrade before your next evaluation run, and treat the log-leak fixes as retroactive: if you have ever shared an Inspect log directory with a client, a subcontractor or a CI artifact store while pointing at a self-hosted vLLM or SGLang endpoint, rotate that key rather than assuming the upgrade covers it. The limit-enforcement fixes are the cost control — a bridged agent that kept calling the model after its limit was reached is a bill you only discover after the run.

evaluationcredential-leaksinspect-ai
Inspect AI v0.3.290 release
15 NovemberAgents

LangGraph 1.2.22 Lands With Checkpoint 4.3.2, Checkpoint-Postgres 3.2.1 and Prebuilt 1.1.2 as a Single Performance Pass Over the Superstep Loop — `add_messages` Skips Conversion for Plain Messages, Pending Writes Are Filtered to the Given Tasks Before Their Statuses Are Read, Update Keys Are Matched Against a Set on Wide States, Only Failed Futures Are Checked for the Runner Stop Condition and Untracked and Delta Channels Are Resolved Once Per Run — Alongside the Release's One Behavioural Fix, a Child Graph Streamed on Its Own Thread Reaching a Caller That Streams Subgraphs

The 14 November release publishes four packages together: langgraph 1.2.22 (#9702), langgraph-checkpoint 4.3.2 (#9699), langgraph-checkpoint-postgres 3.2.1 (#9700) and langgraph-prebuilt 1.1.2 (#9701). The single functional fix is in streaming — a child graph invoked on its own thread now reaches a caller that streams subgraphs (#9698) — and the rest of the core release is work removed from the hot path: `add_messages` skips message conversion when the messages are already plain (#9631), pending writes are filtered to the given tasks before their statuses are read (#9634), update keys are matched against a set rather than scanned on wide states (#9632), only failed futures are checked for the runner stop condition (#9630), and untracked and delta channels are resolved once per run instead of per superstep (#9629). The checkpoint package stops `InMemoryStore` search continuing past the requested page (#9633) and deduplicates batched store reads with a dictionary (#9636); the Postgres saver lets lone store reads skip the pipeline, skips its lock for connection pools in the async saver and avoids an extra thread hop when loading pending writes; prebuilt now formats the `call_model` error message only when an error is actually raised.

JingLabs read

Adopt on your normal cadence — there is no API change to review, and the gains land where long agent runs actually spend time: state updates, pending writes and store reads on every superstep. The streaming fix is the one to check deliberately if you invoke a subgraph on its own thread and render its output live, because until now that output simply did not arrive and looked to a user like an agent that had stopped thinking.

langgraphperformancestreaming
LangGraph 1.2.22 release
15 NovemberTooling

Langfuse 4.80.0 Binds a Session to the User ID It Was Issued For and Routes SSO-Domain Users to SSO From Invitations and Sign-Up, Adds Google AI Studio and Microsoft Azure as Gateway Providers Under a Section Renamed From AI Gateway to Connections & Models, and Makes Gateway Keys Editable and Restrictable to Model Patterns — With Custom Base URLs on OpenRouter Connections Covered by a Test That Rejects Private-Network Endpoints

The 13 November release opens with two authentication fixes: sessions are now bound to the user ID they were issued for (#20078), and users on an SSO domain are sent to SSO from invitations and sign-up rather than the password path (#19705). On the gateway side, Google AI Studio (#20086) and Microsoft Azure (#20085) join as providers, the section is renamed from AI Gateway to Connections & Models (#20112), gateway keys become editable (#20142) and can be restricted to model patterns (#20139), and OpenRouter connections accept custom base URLs (#20170) with a test asserting that private-network endpoints are rejected (#20177). The tracing table gains a topic filter and a topic column (#19120), API keys are masked in the interface (#20151), typed OTLP envelopes are decoded without building a document tree, ClickHouse query parameters are sent in the request body by default, skill size and file-count limits become configurable, and prompt labels can be removed through the API and MCP. The release lists around fifty changes in total and is not marked as carrying a security advisory.

JingLabs read

Deploy it if you self-host Langfuse for client work: a session bound to the user it was issued for is a correctness property you are implicitly claiming in any processing agreement that covers trace data, and it is cheaper to ship than to explain. The model-pattern restriction on gateway keys is the operational win — it lets you hand a project a key that can reach one model family and nothing else, which is the control most teams want and currently approximate with a separate account.

langfuseauthenticationgateway-keys
Langfuse v4.80.0 release
15 NovemberTooling

AI SDK `ai` 7.0.172 Stops `experimental_extract` and `experimental_decide` Silently Fetching Remote File URLs Through Global Fetch and Now Requires an Explicit `experimental_download` Hook for Them, Pointing Callers That Handle Untrusted URLs at a DNS-Protected Transport Built With `createDownload({ fetch })`, While Inline File Data Continues to Work With No Hook at All

The 13 November patch release changes how two experimental APIs obtain remote files. `experimental_extract` and `experimental_decide` previously downloaded a remote file URL silently through global fetch; they now require an explicit `experimental_download` hook before they will fetch one, and the release notes direct callers handling untrusted URLs to supply a DNS-protected transport via `createDownload({ fetch })`. Inline file data continues to work with no hook supplied. The release otherwise carries dependency updates to `@ai-sdk/provider-utils` 5.0.81 and `@ai-sdk/gateway` 4.0.145.

JingLabs read

Upgrade and expect it to break something, which is the point: any `extract` or `decide` call that passed a URL will now stop until you hand it a hook, and that is a server-side fetch of a URL the model or a document supplied — the classic path from a document-processing feature to an internal metadata endpoint. Write the hook with the guarded transport rather than re-wiring global fetch to get the old behaviour back.

ai-sdkssrffile-downloads
AI SDK `ai` 7.0.172 release
14 NovemberAgents

Claude Code 2.1.325 Fixes a Security Issue in How zstd-Compressed Responses Are Decoded and Turns Three Defaults Toward Asking — Sandboxed Bash Commands Now Follow the Normal Permission Flow Unless `sandbox.autoAllowBashIfSandboxed: true` Is Set, Read-Only Git Commands Ask First in a Repository That Is Not the Project's or One You Trusted, and Scheduled Tasks and `/loop` Ask Before Running a Skill That Declares `allowed-tools` or Hooks — Alongside Bash Permission Corrections Where an Allow Rule Could Run a Different Program Than the One It Names and Some Compound Commands Ran Without Asking

The 13 November release opens with a fix for a security issue in how zstd-compressed responses are decoded, then changes three defaults in the direction of prompting. Sandboxed Bash commands no longer run unprompted: they follow the normal permission flow unless `sandbox.autoAllowBashIfSandboxed: true` is set, and managed settings that turn the sandbox on need that flag in the highest-ranking managed source. Read-only git commands now ask first in a repository that is not the project's or one you trusted — naming it with `--add-dir` rather than the `additionalDirectories` setting restores silent running — and scheduled tasks and `/loop` ask before running a skill that declares `allowed-tools` or hooks unless `Skill(name)` is in `permissions.allow`. The permission fixes continue the previous release's sweep: a Bash allow rule could run a different program than the one it names, some compound commands ran without asking, some deny and ask rules did not apply to certain Bash commands, deny rules were not applied to a permission approval arriving after a restart in self-hosted runner and `claude remote-control` sessions, and the sandbox did not fully protect a worktree's settings and hooks or a linked worktree's shared git folder. The sandbox now also refuses sandboxed writes to `.claude` settings, skills, agents, commands and hooks in added directories, and Claude Code's own helper programs — its network bridge, ripgrep and local git among them — run without its sign-in tokens, API keys or the mTLS client key passphrase in their environment.

JingLabs read

Upgrade, but schedule it rather than letting it land mid-week on a client project: three defaults now ask where they previously did not, and the one that will bite is unattended work — a scheduled task or a `/loop` running a skill with `allowed-tools`, or a sandboxed Bash step in a pipeline, will now stop and wait for a human who is not there. Decide deliberately which of `sandbox.autoAllowBashIfSandboxed` and `Skill(name)` allow rules you actually want, because setting them back wholesale restores exactly the silent execution this release stopped.

claude-codepermissionssandbox
Claude Code v2.1.325 release
14 NovemberAgents

Claude Agent SDK for TypeScript 0.3.325 Fixes Deny Rules That Named an In-Process SDK MCP Tool or Its Server and Still Left That Tool in Claude's List and in `system/init`, Adds a `hook_no_verdict` Warning When a `PreToolUse` Hook Cannot Run, Cannot Answer or Times Out Without Refusing Its Tool Call, and Stops Auto-Approving Sandboxed Bash Unless `autoAllowBashIfSandboxed: true` Is Set

The 13 November release, at parity with Claude Code 2.1.325, corrects a case where `disallowedTools`, `permissions.deny` or `always_deny` naming an in-process SDK MCP tool or its server — or matching it with a glob — left that tool in Claude's tool list and in `system/init`. It adds a `system/informational` warning tagged `hook_no_verdict` for a `PreToolUse` hook that cannot run, cannot answer or times out without refusing its tool call, adds `invalid_config_file` to the `config_file_invalid` startup failure result carrying the broken file's path and its backup's path, and adds `managed_lock` to `plugin_errors` on `system/init` to name the managed `enabledPlugins` entry that dropped a plugin copy. `applyFlagSettings()` now rejects a value that would make Claude Code discard its settings layer, applying nothing and keeping the settings from earlier calls. The release also carries the host-facing changes: sandboxed Bash commands are no longer auto-approved unless `autoAllowBashIfSandboxed: true` is set, read-only git commands in a repository that is not the working directory's, an additional directory's or a trusted one go through the permission flow, `archiveSession()` and `unarchiveSession()` arrive with an `archived` field on listed sessions, and `Query.reloadPlugins()` takes `refuseIfBusy`.

JingLabs read

Treat the deny-rule fix as the reason to upgrade now if you embed SDK MCP tools in your own host: a rule you wrote, that raised no error, still left the tool advertised to the model — and an in-process tool is usually the one wired straight into a client system. The `hook_no_verdict` warning is the other thing to act on; route it into whatever you already alert on, because a `PreToolUse` hook that times out silently is a review gate that stopped existing without telling anyone.

14 NovemberTooling

AI SDK `ai` 7.0.173 Stops In-Place Schema Validation and Input Refinement From Changing Approved Tool Arguments During Approval Replay, and Gives `WorkflowAgent` a `toolApproval` Configuration That Overrides a Tool's `needsApproval` and Returns `execution-denied` Without Pausing the Workflow, Plus a `timeout` Object of `totalMs`, `stepMs`, `firstChunkMs` and `chunkMs` That Ends a Model Step Even When the Provider Stream Ignores the Abort Signal

The 13 November release fixes approval replay, where in-place schema validation or input refinement could change the tool arguments a caller had already approved. It adds `toolApproval` to `WorkflowAgent`, accepted in the constructor or per `generate()` and `stream()` call, taking precedence over a tool's own `needsApproval`, with its functions running in workflow context outside the durable model steps — calls it approves run in the same step, and calls it denies receive an `execution-denied` tool result without pausing the workflow. `generate()` and `stream()` now accept `timeout: { totalMs, stepMs, firstChunkMs, chunkMs }` in addition to a plain number, where `stepMs` limits each model call, `firstChunkMs` and `chunkMs` limit the wait for streamed output, invalid values are rejected with an `InvalidArgumentError`, and a timeout also ends a model step when the provider stream ignores the abort signal. The release further aligns `WorkflowAgent`'s `prepareStep` results with `ToolLoopAgent` — returned `instructions` replace the step's instructions and carry forward, `providerOptions` merge with the agent options and `headers` merge over the call's headers — and routes model-call warnings and the default step-limit warning through the AI SDK warning logger under `AI_SDK_LOG_WARNINGS`.

JingLabs read

The approval-replay fix is the reason to upgrade, and it is worth stating plainly to a client: until this release the arguments a person approved and the arguments that ran could differ after a refinement step, which is the one failure that makes a human-in-the-loop control worth nothing. If you run `WorkflowAgent` in production, adopt the `timeout` object in the same pass — a step limit that still ends the call when a provider ignores the abort signal is the difference between a stuck durable run and a bounded one, and a stuck run bills for as long as nobody looks.

ai-sdktool-approvaltimeouts
AI SDK `ai` 7.0.173 release
14 NovemberAgents

MCP Merges EU Cyber Resilience Act Stewardship Guidance Into Its Security Policy, Stating That the Project and Its Official SDKs Publish Software Ultimately Intended for Commercial Activities, Placing Itself Under the Linux Foundation CRA Stewardship Framework, and Requiring a Maintainer Who Learns of an Actively Exploited Vulnerability or a Severe Incident Such as a Release-Process Compromise to Notify a Core or Lead Maintainer Immediately, Who Alone Contacts the Linux Foundation Steward Against the CRA's 24-Hour Early Warning and 72-Hour Notification Deadlines

PR #3526, merged on 13 November, adds a CRA section to `SECURITY.md` and to `docs/community/policies.mdx`, with a pointer from the contributor ladder. The text states that the Model Context Protocol project publishes software, including the official SDKs, that is ultimately intended for commercial activities, and that the project is supported under the Linux Foundation CRA stewardship framework, linking the Linux Foundation's CRA guidance for open source projects. It names GitHub Security Advisories as both the normal and the emergency reporting mechanism, asks a reporter to state at the start of the report that a vulnerability is being actively exploited or that an incident is under way, and sets the maintainer-side rule: whoever learns of active exploitation or a severe incident such as a compromise of the release process notifies a Core or Lead Maintainer immediately in the `#security-disclosures` Discord channel, while fixing the problem and never instead of fixing it, and that maintainer alone contacts the Linux Foundation CRA steward so the project speaks with one voice against the CRA's early warning within 24 hours and fuller notification within 72 hours. The policy also states that a vulnerability with no evidence of exploitation is not a CRA escalation event and follows the normal advisory process.

JingLabs read

Read this if you ship MCP servers or clients to European clients, because it marks where the obligation sits and where it does not: the specification project now has a named steward and a documented escalation path, and you — as the party placing a product on the EU market — inherit neither. Use it as a template for your own policy rather than as cover, because a client's procurement questionnaire will ask who you notify within 24 hours of learning of active exploitation, and pointing at the Linux Foundation is not an answer to that question.

mcpcraeu-compliance
MCP specification PR #3526
13 NovemberAgents

Claude Code 2.1.323 Adds an Experimental Opt-In Code Mode in Which Claude Writes JavaScript to Call Its Tools, and Ships Around Twenty Bash Permission and Sandbox Corrections — an Allow Rule With an Attached Wildcard Such as `Bash(ls*)` Skipping the Prompt, Deny and Ask Rules Missing Commands Run Through `sudo` or `env`, `sandbox.excludedCommands` Letting a Command It Does Not Name Run Outside the Sandbox, Write and Edit Reaching a Path Covered by a `Read` Deny Rule, and `claude -p` or the Agent SDK Running Bash Unsandboxed When Sandbox Settings Failed Validation, Which Now Stops at Start-Up and Names the Invalid Setting

The 12 November release introduces Code Mode, described as an experimental opt-in in which Claude writes JavaScript to call its tools rather than issuing tool calls directly, switchable on per user or off for an organisation. The larger part of the changelog is a batch of permission and sandbox fixes: Bash allow rules carrying an attached wildcard such as `Bash(ls*)` could skip the prompt and a rule naming a variable such as `Bash(NODE_ENV*)` now asks, deny and ask rules missed some commands run through `sudo`, `env` and similar wrappers, combined `sudo` flags in an allow rule could skip the prompt, `sandbox.excludedCommands` let a command it does not name run outside the sandbox, the Write and Edit tools could write to a path covered by a `Read` deny rule, an `rm` could be judged from the wrong folder and skip the dangerous-removal prompt, some `lsof` commands ran unprompted, the sandbox could switch off mid-session, sandboxed commands could read Claude Code's own file checkpoint copies, and `claude -p` and the Agent SDK ran Bash unsandboxed when `--settings` or SDK settings enabling the sandbox failed validation — which now halts at start-up and names the setting. Alongside these, `--permission-mode auto` or `defaultMode: auto` previously started in a more permissive mode when auto mode was unavailable and now starts in Manual, a "don't ask again" rule that looks like it holds a secret or would be written to a git-tracked `settings.local.json` lasts for the session only, plugins gain `engines["claude-code"]` so a plugin outside its stated version range is not installed or loaded, and `claude plugin validate` now type-checks a plugin's TypeScript hooks module.

JingLabs read

Upgrade without waiting: this is not one bug but a sweep through the same surface, and several of the entries describe a configured deny or sandbox setting that silently did not apply — including the one where enabling the sandbox through SDK settings that failed validation left Bash running unsandboxed with no error. Treat Code Mode separately: it changes how tool calls are produced, so try it on a throwaway repository and read what it generates before letting it near client work, and note that an organisation can turn it off centrally.

claude-codepermissionscode-mode
Claude Code v2.1.323 release
13 NovemberAgents

AI SDK `ai` 7.0.171 Flips the Default on Tool Error Text So the Model's Own Error Reaches the Client Instead of a Generic Placeholder, With `redactToolErrors: true` to Restore Masking — and Routes File Downloads Through the Provider's Configured Fetch Transport So Azure Image and Vertex Tool-Result Downloads No Longer Hand Bearer Tokens or API Keys to the File Host, With `createDownload` Taking a `fetch` Option for Guarded DNS Validation and Passing the Call's Abort Signal Through

The 12 November release changes what a failed tool call sends to the client: the error text now matches what the model received, instead of the previous generic placeholder, because the placeholder made stored history diverge from the model's view in a way some models reject. The release adds `redactToolErrors: true` to restore the old masking, notes that a tool can throw an error carrying a deliberately safe message from its `execute` function, keeps stream errors masked by default, and adds a warning for streams where the tool error text differs from what the model received and reasoning from a later step follows. Separately, file input downloads now use the provider's configured fetch transport: `createDownload` accepts a `fetch` option so a guarded transport performing DNS validation can be supplied on Node.js, its result can be passed as `experimental_download` to `generateText` and `streamText` and also covers generated file URLs, Azure image and Vertex tool-result downloads are kept out of the auth wrappers so file hosts no longer receive Azure bearer tokens or Vertex API keys, and custom download requests receive the call's abort signal so cancellation and timeouts still work — with the documentation stating that the default URL checks do not resolve DNS and recommending the guarded transport or network egress controls for untrusted URLs. A third fix stops excessive memory and CPU use when validating malformed UI messages by checking each part only against its own type's schemas and stopping at the first invalid message or part.

JingLabs read

Adopt, but read the first change as a default that now moves data outward: raw tool error text reaching the browser is how a connection string, an internal hostname or a row of customer data ends up in a client payload, so either set `redactToolErrors: true` or make every tool throw a message you would be willing to show a client before you upgrade. The download change is the more quietly important one for anyone running Azure or Vertex — until now a file URL supplied by a model could be fetched with your provider credentials attached, and that is worth checking against your own egress rules rather than assuming the new default covers it.

ai-sdktool-errorscredential-isolation
AI SDK `ai` 7.0.171 release
13 NovemberAgents

Claude Agent SDK for TypeScript 0.3.323 Stops `resolveSettings()` Caching a macOS MDM Profile or Windows Registry Policy for the Life of the Process — It Now Re-Reads After Thirty Minutes and Sooner After a Failed Read — and Adds Alpha `machinePolicy.didNotLoad` to Tell a Host That a Policy Source May Exist and Did Not Load, Alpha `matchDeniedModels()` to Report Which Models a `deniedModels` List Blocks by Claude Code's Own Entry Rules, and a Periodic `tool_progress` Heartbeat While a Turn Waits on Long-Running Hooks

The 12 November release, at parity with Claude Code v2.1.323, is mostly about a host knowing the state of the policy and session it is embedding. `resolveSettings()` previously kept its first reading of a macOS MDM profile or Windows registry policy for the life of the process and now re-reads after thirty minutes, and sooner after a failed read; its result gains the alpha `machinePolicy.didNotLoad`, which tells a host when a machine policy source may be present and did not load, and the alpha `matchDeniedModels()` reports which models a `deniedModels` list blocks according to Claude Code's own entry rules. A periodic `tool_progress` heartbeat is now emitted while a turn waits on long-running hooks, with `tool_name` set to the hook event and `tool_use_id` beginning `hook-`. The release also fixes progress notifications from SDK MCP servers being dropped for tool calls still running when the set of SDK MCP servers changed, an MCP server removed and re-added with `setMcpServers()` staying `needs-auth` with no tools if a tool call had tried to reach it in between, `forkSession()` with `upToMessageId` bringing back messages kept after a compaction summary, `getSessionMessages` omitting a queued prompt that directly follows a compaction summary, and most `initialize` options such as agents and skills being ignored when a `SessionStart` hook supplied the first message.

JingLabs read

Adopt if you embed the SDK in anything a client or an IT department configures centrally, because the policy fixes are the kind of failure nobody reports: a machine policy that failed to load looked identical to no policy, and one that changed on disk was never re-read, so an agent could run all day under settings an administrator believed they had revoked. The hook heartbeat is the smaller but immediately useful one — a long-running `PreToolUse` hook previously looked like a hung turn to any UI built on the stream.

claude-agent-sdkmachine-policyhooks
Claude Agent SDK for TypeScript v0.3.323 release
13 NovemberTooling

Langfuse 4.79.0 Records Read-Access Events for MCP Tools in the Audit Log, Puts Scheduled Trace Transcript Evaluations on a Timer, and Promotes OpenRouter, xAI and Vercel AI Gateway From Pre-Release to Generally Available Gateway Providers Alongside Generally Available Custom Base URLs and Extra Headers on All Deployments — With Cached Resolve Contexts Now Evicted When a Key Owner's Organisation Role Changes and the Model Catalogue Cache Versioned

The 12 November release adds read-access events for MCP tools to the audit log (#19759), so reads through the MCP interface are recorded rather than only writes, and adds the ability to schedule trace transcript evaluations (#20006) instead of triggering them manually. On the gateway side, OpenRouter (#20002), xAI (#20004) and Vercel AI Gateway (#20020) were added as pre-release providers and then made generally available (#20028), custom base URLs became generally available (#20030), and extra headers are now available on all deployments (#20058). The release also adds MCP tools for managing the default evaluation model (#20032) and a `SUBSTITUTE_OK` no-data mode for monitors (#19981), and fixes several gateway behaviours: provider names are kept out of the delete dialog replay (#20025), cached resolve contexts are evicted when a key owner's organisation role changes (#20067), the model catalogue cache is versioned (#20073), and the external code-eval endpoint is parsed with the canonical outbound URL parser (#20082).

JingLabs read

Worth deploying if you run Langfuse for a client under a data processing agreement: audit logging that covers reads, not just writes, is the difference between being able to answer "who looked at this trace" and not, and that question arrives from a GDPR accountability review rather than from engineering. The cache eviction on role change belongs in the same category as the rest of this week — a permission you revoked was still being served from a cached context until the key was touched.

langfuseaudit-loggingevaluation
Langfuse v4.79.0 release
12 NovemberAgents

MCP Publishes a Draft `io.modelcontextprotocol/files` Extension That Keeps File Bytes Out of the Model's Context — a Tool Argument Marked `x-mcp-file` Is Filled In by the Client, a `tools/call` Carrying Only `id`, `mimeType` and `size` Comes Back as an `upload_required` Result With Per-File Upload Targets and an Opaque `requestState`, and the Client Retries the Same Call After a Direct `PUT` or `POST` — With `3xx` Treated as a Failed Transfer, `Authorization` and `Cookie` Barred From Targets, and `requestState` Bound to the Tool Name, Arguments, Targets and Authenticated Principal

The File Uploads Working Group published a draft extension, announced on the MCP blog on 10 November, for moving files between clients and tools without routing the bytes through the model. The extension is identified as `io.modelcontextprotocol/files` and works with protocol revision `2026-07-28` and later: a server advertises it in `server/discover` with `upload` and a `maxInlineBytes` cap on total inline data per request, a client declares `upload` and `download` in the `io.modelcontextprotocol/clientCapabilities` metadata of every request that may need it including `tools/list`, and a server marks a file argument in `Tool.inputSchema` with `x-mcp-file` carrying optional `accept` and `maxSize`. Small files travel inline as base64 in `data`; for anything larger the client calls the tool with metadata only — `id`, `mimeType` and `size` required, `name` and a base64url SHA-256 `digest` optional — so the server can check permissions and quota before any bytes move, then returns the new `upload_required` result type with one target per file and an opaque `requestState` the client echoes back unchanged on the retry, following the Multi Round-Trip Requests pattern. The draft binds `requestState` to the tool name, arguments, file targets and authenticated principal with a mandatory expiry, requires at-most-once atomic consumption for tools that are unsafe to run twice, requires the server to confirm with storage that each file arrived and verify the digest before running the tool, and sets out transfer rules: absolute HTTPS targets without userinfo, `3xx` treated as a failed transfer, `Authorization` and `Cookie` headers barred, `include` credentials honoured only for `path` or same-origin targets, no connections to non-global addresses without an allowlist, and redaction of URLs, headers, `requestState` and inline data from logs. Downloads run the other way through a `downloads` array under the result's `_meta`, which the draft itself marks as an open question that may become `resource_link`, and there is no reference implementation yet.

JingLabs read

Watch rather than build: this is the first protocol-level answer to a question every MCP server that touches documents has been answering privately, but it is an experimental draft with no reference implementation and an unsettled download shape, and the working group only expects it stable before the end of the year. What is worth doing this week is reading its security section against the bespoke file handling you already shipped — the rules about refusing redirects, never attaching credentials to a cross-origin target, verifying the digest server-side before acting, and keeping upload URLs out of model context are the four places a hand-rolled convention usually gets it wrong.

12 NovemberAgents

MCP Puts Specification Releases on a Fixed Six-Month Cadence — SEP-3398 Sets Publication for the Last Tuesday of March and September, Soft Freeze Two and a Half Months Out, Tier 1 SDK Betas at One and a Half Months, and Hard Freeze at One Month Where Only Critical Security or Release-Blocking Interoperability Fixes Pass a Full Core Maintainer Vote — With Version `2027-03-30` Targeted Next and a Proposal That Misses the Freeze Moved to a Later Release Rather Than Delaying the Spec

A post published on the MCP blog on 11 November sets out the release process written up as SEP-3398, which the maintainers describe as de facto release guidance from now on. Specification releases move to a regular six-month schedule published on the last Tuesday of March and September, with the next version targeted as `2027-03-30`; planning starts eight months before a release, Core Maintainer reviews begin six months out and run to soft freeze, soft freeze at two and a half months requires every proposal in the release to be marked Final and merged after which only in-scope fixes and clarifications are accepted, Tier 1 SDK betas arrive at one and a half months, and hard freeze at one month admits only critical security fixes or release-blocking correctness and interoperability defects by full Core Maintainer vote. A proposal that is not ready moves to a later release rather than delaying the spec, and an SDK that is late is documented as a gap rather than being allowed to move the release date. The post states explicitly that this changes how a release is prepared and not MCP messages or version negotiation, so nothing needs to change in an existing client or server, that specification versions continue to use dates, and that Luca Chang joins Den Delimarsky and David Soria Parra as a Release Manager for the next cycle.

JingLabs read

Useful for planning and nothing else: a European SMB quoting MCP work can now tell a client when the protocol surface it is building against will next move, and that Tier 1 SDK betas land about six weeks earlier, which is the point at which it is worth scheduling a day of compatibility testing. Do not read it as a promise that the ground stops shifting between releases — extensions such as the file-uploads draft are moving outside this cadence and the SDKs ship behaviour changes most weeks, so two spec releases a year is a statement about the specification document, not about your integration's maintenance load.

12 NovemberAgents

Pydantic AI 2.68.0 Carries Approvals and Prompt-Injection Checks Across Into Durable Runs — `Permissions` Remembered Approvals Are Now Honoured Inside Durable Execution and `PromptInjectionDefender` Semantic Classification Runs as Durable Operations So It Works on Temporal, While `RequestInput` Adds In-Run Approvals and Answers and Moves `AskUser` to the Deferred Pipeline — Alongside `OutputTokenLimitExceeded`, Which Makes a `max_tokens` Cut-Off a `ModelFallback` Trigger, and Escaping of User and Tool Content That Looks Like an Application Frame

The 11 November release, published on 12 November, groups several changes around controls that had not crossed over into durable execution. Remembered `Permissions` approvals are now honoured inside durable runs, and `PromptInjectionDefender` semantic classification runs as durable operations so it works on Temporal; separately, `RequestInput` adds in-run approvals and answers, `AskUser` moves to the deferred pipeline, and deferred calls gain `kind` and `answered_by`. The release also adds `OutputTokenLimitExceeded` so that hitting `max_tokens` becomes a `ModelFallback` trigger to the next model, lowers a configured `max_tokens` above a Claude model's maximum output to that maximum, escapes user and tool content that resembles an application frame, adds `DelegationTasks.discover()` and stops one damaged saved task blocking `DelegationTasks.opened()`, runs `SubAgents` delegations to durable delegates as Temporal and DBOS child workflows, and renames a set of harness and sub-agent event fields with deprecated aliases kept in place. `TieredCompaction` now reports when it cannot reach `target_tokens` because its tiers retain more than the target, and the `genai-prices` floor is raised so Anthropic fast mode responses are priced at fast mode rates.

JingLabs read

Adopt promptly if you run Pydantic AI agents on Temporal or DBOS, because two of these are not features but corrections: an approval a user had already granted was not being honoured in durable runs, and the injection classifier was not running there at all. That is the same shape as the rest of this week — a control that was configured, raised no error, and was not doing its job — and the lesson generalises past this release: when you move an agent to durable execution for reliability, assume no guardrail crossed over until a test proves it fired.

pydantic-aidurable-executionapprovals
Pydantic AI v2.68.0 release
12 NovemberAgents

AI SDK `ai` 7.0.170 Patches the Message Queue It Shipped Two Days Earlier — a Pending `experimental_sendQueuedMessageNow` Held Open by an Asynchronous Tool Callback Could Resume an Abandoned Chat's Queue After the User Had Switched Chat ID and Transport, Sending That Chat's Queued Messages and History Through the Replacement, and `AbstractChat` Now Compares the Stop Generation Before Resuming — Plus an `Output.array` and `streamObject` Fix That Parses Completed Elements Incrementally Instead of Reprocessing the Whole Array on Every Chunk

The 11 November patch contains two fixes. The first concerns the opt-in message queue added in 7.0.168: `experimental_sendQueuedMessageNow` stops the active request and then resumes the queue, and if an asynchronous tool callback held `stop()` open the user could switch chat IDs and transports while the call was still waiting, after which the old continuation resumed the abandoned queue and sent its messages and history through the new transport. `AbstractChat` now records the expected stop generation before calling `stop()` and returns without resuming if a later stop or dispose has run in the meantime; the public API is unchanged and tests were added for both the stop and dispose paths plus a regression test in `@ai-sdk/react`. The second fix addresses excessive CPU use when streaming long arrays with `Output.array` or `streamObject`, which previously reparsed and revalidated the whole accumulated array on every text chunk and now parses and validates completed elements incrementally.

JingLabs read

Upgrade if you turned on the queue when it appeared two days ago — switching conversation while a tool call is still running is ordinary user behaviour, and the failure it produced is one chat's history arriving over another chat's transport, which is a confidentiality problem rather than a glitch. The broader point is worth keeping: an opt-in feature one patch old has not yet met your users, so in client-facing work it is cheaper to let a new convenience API sit for a few releases than to be the deployment that finds its edge cases.

ai-sdkchat-uxmessage-queue
AI SDK `ai` 7.0.170 release
11 NovemberAgents

The MCP TypeScript SDK Closes a Gap in `Mcp-Param` Header Binding — a `tools/call` Whose Body Argument Declared With `x-mcp-header` Was an Object or Array Skipped the Header Check Altogether and Reached the Tool, and Is Now Rejected With `400` / `-32020` (`HeaderMismatch`) Whether or Not the Header Was Sent, as Is an Integer Outside the Safe Range Accompanied by a Header the Server Cannot Compare Against It

Pull request #3167, merged on 10 November as a patch to `@modelcontextprotocol/core-internal` and `@modelcontextprotocol/server`, changes what the server does when a body argument declared with `x-mcp-header` has no header form. The previous code treated a non-primitive value as a fault for parameter validation to own and skipped the header check with a `continue`, so the call went on to the tool; the merged code returns a rejection instead — `param-header-missing` when the header is absent and `param-header-mismatch` when it is present — and an unsafe-range integer now also fails when a header accompanies it, on the stated grounds that the header cannot be compared with a value that has no header form. The changeset records the rejection as `400` / `-32020` (`HeaderMismatch`), and the change currently sits in `.changeset/` on top of v2.4.0 rather than in a published release.

JingLabs read

Test this if you use `Mcp-Param` headers as a trust boundary — binding a tenant or user identifier carried in a header to the argument the tool actually receives — because until the patch ships a client could sidestep that binding by sending the argument as an object or array. The safe posture in the meantime is to treat the header check as advisory and re-validate the same value inside the tool handler, which is also the version of the control you can still describe accurately to a client.

mcptypescript-sdkheader-validation
MCP TypeScript SDK PR #3167
11 NovemberAgents

AI SDK `ai` 7.0.168 Adds an Opt-In `experimental_queue` to `useChat` and `Chat` Across React, Vue, Svelte and Angular — Messages Sent While a Response Is Running, or While the Assistant Waits on a Tool Approval or Tool Result, Are Held and Dispatched One at a Time in Order Rather Than Starting a Second Request That Races the First Into the Same Message List — With `experimental_queuedMessages`, `experimental_removeQueuedMessage(id)` and `experimental_sendQueuedMessageNow(id)`, and a 7.0.169 Follow-Up That Keeps Request Options When the Queue Sends a Tool Approval First

`ai` 7.0.168, released on 10 November, adds an `experimental_queue` option to `useChat` and `Chat` in the React, Vue, Svelte and Angular bindings. The pull request states the behaviour it replaces: without it an application has to disable its input while a response streams, because sending anyway starts a second request that races the first into the same message list. With the option enabled, messages sent while a response is running — or while the assistant is waiting on a tool approval or a tool result — are queued and sent one at a time in order after each response completes; `stop` or an error pauses the queue and the next message or an explicit send resumes it; and three helpers are added in `experimental_queuedMessages`, `experimental_removeQueuedMessage(id)` and `experimental_sendQueuedMessageNow(id)`. The feature is entirely client-side, so it works with any backend, it is off by default, and the follow-up 7.0.169 keeps the request options when the queue sends a tool approval first and holds the queue while an asynchronous `sendAutomaticallyWhen` decides.

JingLabs read

Adopt this in any client-facing chat you ship: the behaviour it replaces — an input disabled while the assistant works — is the first thing users complain about and the workaround most teams never get round to building. Be clear with yourself about what it is not, though, since it queues on the client rather than steering on the server: a queued message cannot change what the running response is already doing, so an agent on a long tool run still needs the separate steering path.

ai-sdkusechatchat-ux
AI SDK `ai` 7.0.168 release
11 NovemberAgents

`@ai-sdk/harness-claude-code` 1.0.184 Lets a Host Hand Permission Decisions to Claude Code's Own Classifier — `createClaudeCode({ autoMode: true })` Makes `allow-reads` and `allow-edits` Request Claude Code's `auto` Mode in Place of the Adapter's Deterministic Edit, Shell and Path Rules, So Every Non-Host Tool Call Claude Code Escalates Through `canUseTool` Arrives as a `tool-approval-request`, Including Reads That Would Normally Be Auto-Approved — While the Documentation Warns That Eligibility May Leave Auto Mode Inactive and the Effective Mode Can Only Be Read From `init` and `status` Raw Stream Parts

Released on 10 November alongside `ai` 7.0.169, the Claude Code harness adapter gains an opt-in `autoMode` setting. With `autoMode: true`, the `allow-reads` and `allow-edits` permission modes request Claude Code's classifier-based `auto` mode instead of the adapter's deterministic edit, shell and path approval rules: the adapter removes its blanket edit and shell ask rules, stops deferring calls before classification, and every non-host tool call Claude Code escalates through `canUseTool` becomes a `tool-approval-request`, including reads that would otherwise be auto-approved. Host-executed tools keep bypassing the classifier through the adapter's `mcp__harness-tools__*` allowance and stay governed by `HarnessAgent`'s `toolApproval`, other MCP servers do not receive that allowance, inactive built-in tool restrictions remain, and the setting defaults to `false` and has no effect under `allow-all`, which still uses `bypassPermissions`. The provider documentation added in the same change states that auto mode depends on Claude Code's provider and model eligibility and that requesting it does not guarantee it is active or that an unavailable mode falls back in a particular way, so the effective mode has to be observed from `permissionMode` on `init` and `status` raw stream parts, of which the adapter forwards only `{ type, subtype, permissionMode }`.

JingLabs read

Test it rather than trusting it, and log the effective mode instead of assuming the setting took — the documentation is unusually direct that eligibility can leave auto mode inactive with no defined fallback, which is exactly the gap that turns a permission posture you described to a client into one you cannot evidence afterwards. The honest framing is that `autoMode` trades a deterministic, auditable rule set for a model's judgment: reasonable for an internal developer harness, harder to justify where the agent is working in a client's production repository.

ai-sdkclaude-codepermission-modes
`@ai-sdk/harness-claude-code` 1.0.184 release
June 9 source scan

China-source signal scan

Signals from Chinese tech media — IT Home, 36Kr, OSCHINA — read in the original.

Updated after each source pass

Agent-era supply chains are getting noisier

IT Home reported that Microsoft temporarily disabled dozens of GitHub repositories after suspected tampering inserted credential-stealing malware into projects connected to Azure and AI developer tools.

JingLabs read

For teams using coding agents, repository trust now belongs in the same checklist as prompt quality: pin dependencies, review scripts, rotate secrets, and isolate agent sandboxes.

SecurityGitHubAgents

Apple is turning Xcode into an agent workspace

Apple's new developer tooling includes an intelligence framework, Core AI for on-device models, Xcode 27 agent coding features, MCP-style tool hooks, and verification tools for tests and previews.

JingLabs read

Platform IDEs are absorbing the agent loop. The buying question shifts from which chatbot writes code to where review, testing, device context, and deployment controls live.

XcodeMCPOn-device AI

Biology agents need data rails before bigger models

36Kr republished Machine Heart's write-up of Anthropic's biology-agent research: direct database browsing produced unstable results, while deterministic retrieval through gget virus pushed agents above 90% accuracy.

JingLabs read

The lesson travels beyond biotech. Give agents stable APIs, logs, schemas, and checkable tools before asking them to improvise through messy portals built for human clicking.

Data infraScience agentsReliability

Alibaba reorganizes around model-to-product execution

IT Home reported that Alibaba merged Tongyi model work and Future Life Lab into Token Foundry under CEO Eddie Wu, with Jingren Zhou becoming chief scientist and AI Future Research Institute lead.

JingLabs read

Large model vendors are collapsing research, product, and agent application teams. That points to faster verticalization and more platform pressure for downstream integrators.

QwenAI orgPlatforms

Coding benchmarks are moving from pass rate to mergeability

OSCHINA's June 9 feed highlighted Cognition's FrontierCode, a benchmark built with open-source maintainers to judge whether AI-generated pull requests would actually be merged.

JingLabs read

This matches how production teams should evaluate coding agents: scope discipline, test quality, style, maintainability, and reviewer trust matter as much as green checks.

BenchmarksCode reviewOpen source

AI systems

Model releases, agent frameworks, MCP patterns, eval tooling, and production AI workflows.

Developer tooling

Framework updates, open-source libraries, coding agents, platform shifts, and delivery practices.

Business impact

What is mature enough to adopt, what needs caution, and where small teams can move faster.

Editorial standard

I write the brief myself and hold it to the same standard as client work: source-led, concise, and clearly separated from raw reporting.

  • Every item is read at the original source — release note, paper, or repository — before a word is written.
  • Sources are cited in every issue, with facts kept separate from interpretation.
  • Each note is written from a practitioner's point of view, never paraphrased from press material.
  • Advertorials, sponsored drops, and thin reposts are skipped unless there is a clear primary signal.
  • Visuals are original, licensed, or generated.
  • Each note answers one question: should a European SMB watch, test, adopt, or ignore this.