A budget dial for auto mode, a video for the diff: AI coding tools shipping Sep. 11–18 (2026)

The qualifying releases in this issue shipped between Friday, September 11 and Friday, September 18, 2026. The cutoff is 10:00 a.m. Pacific on September 18, so anything published later that day belongs to next week's issue.

Two things moved this week. Automatic model selection became a setting a team can point at a cost target, and per-person spending got an approval path where it used to have a hard stop. At the same time, the tools started producing evidence for the work an agent did: GitHub Copilot's reviewer now runs commands and closes its own resolved comments, JetBrains Junie records a video of the feature it just exercised, and Kiro keeps agent output as artifacts you can reopen.

Engineering managers can scan the summary table first, then use the review action attached to each release to decide what to pilot, what belongs in policy, and what is only worth watching.

The week in one view

Tool and release	Date	What changed	Why it matters	First review action
GitHub Copilot: auto model selection tiers	Sep. 14	Automatic model selection now offers three tiers — efficiency, balance, and intelligence — that set how much weight the router gives cost, quality, and response time per prompt. All three draw on the same model set, and usage bills at whichever model auto picks. Paid subscribers keep the 10% discount on usage billed through auto. 1	Model routing becomes a policy a lead can set per team, and a tier is easier to defend in a budget conversation than an instruction to use cheaper models.	Set one tier per team, then compare billed usage and model mix after two weeks.
GitHub Copilot: budget requests and governance metadata	Sep. 15–16	A member who exhausts their AI credits can request more, and the request routes to the account that pays so an owner or billing manager can approve, adjust, or deny it. Separately, public preview lets Copilot suggest allowed values when an admin defines a repository custom property, behind its own policy toggle. 2 3	The person blocked by a limit is usually not the person who can lift it, and custom properties are how large repository fleets scope their rulesets.	Name who reviews budget requests in each paying organization before the first one arrives.
GitHub Copilot: code review validation	Sep. 11	Copilot resolves its own review comments once a later commit addresses them, writes a context-aware commit message when you apply its suggestion, and runs shell tools behind the agent firewall during review. Lite reviews now come from an ensemble of agents. 4	Review threads stop accumulating as archaeology, and a reviewer that can run tests verifies claims a diff alone cannot settle.	Re-run a Lite review on a change that previously produced nit-heavy output and compare the findings.
GitHub Copilot: adoption metrics	Sep. 11–17	The impact dashboard reports how many active users engage with each Copilot feature over 28 days, the report APIs expose the same breakdown, and CLI reports add skills, custom agents, MCP servers, slash commands, and plugins. VS Code agent activity joined the same coverage on Sep. 11. 5 6	Enablement spending can now be checked against who actually uses which feature.	Turn on the usage metrics policy and pull one 28-day report before the next budget review.
Claude Code 2.1.269–2.1.276	Sep. 11–18	Eight releases in eight days: gateway request-class and compaction headers, a pricing multiplier up to 10× for internal markups, plugin evaluation with scored reports, synced claude.ai skills and plugins, per-command network allowlists in sandboxed shells, and integrity-verified plugin installs. 7 8	The gateway and pricing work is what a platform team needs before it can attribute agent spend; the plugin work is what a release process needs.	Decide whether internal chargeback should carry a markup now that the `modelPricing` multiplier exists.
JetBrains Junie: `/demo` and a local blend model	Sep. 18	`/demo` builds and launches your app, drives its interface, and returns an HTML report with screenshots and a narrated video, with a CI entry point. Junie Local also replaced its two-model choice with a merged `Qwen3.8-3.6-27B-blend`. 9 10	Verification becomes something a reviewer can watch, and a local model's token efficiency changes what an offline agent costs to run.	Run `/demo` on one feature you would otherwise click through yourself.
Kiro IDE 1.1	Sep. 14	Agents produce durable artifacts — documents, diagrams, code, images — with a preview in the conversation and a full view in Agent Focus. Native ARM64 builds for Windows and Linux, editor foundation on Code OSS 1.131, and enterprise profiles routed to a selected region. 11	Agent output stops disappearing into a transcript, which is what makes it reviewable days later.	Confirm which region an enterprise profile routes to before rolling it out.
Devin	Sep. 11–16	Live voice calls, sessions that wake as you type, security checks always on in Devin Review, MCP secrets moved to each server's page, 21 new OAuth MCP servers, a unified plugin marketplace with organization-required layers, and PagerDuty triggers. 12	Secrets handling, plugin permissions, and automation scope all changed in the same week.	Find where MCP credentials now live in your settings before the next access review.

GitHub Copilot: auto mode gets a cost and quality dial

Automatic model selection now has three tiers, and the tier decides how heavily the router weighs cost against quality and latency for each prompt. Efficiency keeps costs low for short, straightforward work. Balance weighs cost, quality, and latency together and is positioned for everyday requests. Intelligence prioritizes quality for complex tasks. 1 The setting is rolling out in Visual Studio Code, Copilot CLI, and the Copilot app.

Two details shape how a team should treat it. All three tiers select from the same pool of available models, so efficiency narrows the router's judgement instead of removing models from the catalogue; a simple request such as adding a docstring to an existing function can still resolve to a small model under intelligence. And billing follows the model auto actually picked, at that model's rate, with paid subscribers keeping their 10% discount on auto-billed usage. 1 GitHub describes the tiers as a first step toward exposing the trade-offs in model selection, and the tier definitions and the model list behind auto are documented. 13

The practical consequence is that model routing stops being invisible. Two teams can be compared on the same workload, and a tier is a more defensible answer to a finance question than an instruction to use the cheaper model.

Auto menu open in a Copilot composer, listing Efficiency, Balance, and Intelligence, with Balance selected — GitHub's own screenshot of the Auto menu in the Copilot app, where the three tiers are chosen; Balance is the default shown here. The tier sets how auto weighs cost against quality and latency for every prompt in that surface. 1

GitHub Copilot: a request path for exhausted budgets

Until this week, a developer who used up their Copilot AI credits was blocked from the features that consume them. The new flow lets that member request more budget the moment they hit the limit, and the request lands where the money is: requests against an organization budget appear in organization settings, and requests against an enterprise budget appear in enterprise settings. 2

An organization owner, enterprise owner, or billing manager reviews pending requests under "Requests from members", sets an amount for each one, and approves; the member's budget updates to that amount and access returns immediately. 2 The feature is generally available on Copilot Business and Enterprise under usage-based billing, and GitHub notes that enterprises with managed users are excluded. 2 The request flow and the budget setup it depends on are both documented. 14

The same week brought a smaller governance change. In public preview for Business and Enterprise, Copilot can suggest allowed values when an enterprise or organization administrator defines a repository custom property, so a compliance-oriented multi-select property such as FedRAMP arrives with plausible values attached and a yes/no property such as internet-facing arrives with yes and no. 3 Custom properties are one of the main ways organizations scope rulesets, and inconsistent metadata across a large repository fleet is the usual reason ruleset coverage drifts. A dedicated "Repository custom property suggestions" policy controls whether the feature is on. 3

GitHub Copilot: measuring whether any of it landed

The impact dashboard now reports how many active users engage with each Copilot feature on at least two days inside a 28-day window, and the same breakdowns reach the enterprise and organization report APIs as copilot_feature_engagement, split across code completion, agent edit, passive code review, active code review, the Copilot cloud agent, Copilot CLI, and the Copilot app. 5 Adoption-phase reporting gained users_in_phase_28d, which gives the full rolling 28-day population for each phase rather than only the users active that day. 5

The CLI reports gained customization metrics on the same day: top-five lists plus distinct counts for skills, custom agents, MCP servers, slash commands, and plugins. 6 Two boundary conditions matter once these numbers reach a slide. Customer-defined names are hidden and those items are grouped under other, so a report shows the shape of adoption rather than which internal plugin is winning. 6 And plugin totals count only skill invocations associated with a plugin, which makes them a subset of skill totals; GitHub's own guidance is to keep the two apart when reporting. 6

VS Code agent activity was added to the same report coverage on September 11. 15 Access to any of it requires the View Copilot Metrics permission and the usage metrics policy switched on. 5 The field definitions live in the usage metrics API documentation. 16

GitHub Copilot: code review now checks its own work

Four changes landed in Copilot code review on September 11. 4

When you push a commit that addresses a Copilot review comment, Copilot resolves that comment during its rereview, so open threads reflect only the feedback still outstanding. 4 Applying a suggestion from a review comment now produces a commit message written for that change instead of the standard fill-in. 4

Behind those experience changes, the review agent gained the full set of shell tools from the Copilot SDK, running behind the Copilot agent firewall, which lets it run build commands, tests, and targeted scripts while reviewing. 4 The Lite effort level now assembles a review from an ensemble of agents, each contributing its own reading of the code, with Copilot combining the findings into one review. 4

GitHub reports the measured effect of these experiments: the ensemble raised the average number of addressed comments per review by 47% for high-severity findings, 31% for medium, and 11% for low, while cutting review cost by about 8%. 4 Those figures come from GitHub's own experimentation, and the same announcement says developers left more positive feedback on Copilot's comments and saw more high-severity findings with fewer nits. 4

Teams that dismissed Lite as too shallow have a reason to re-test it on one repository. The tool access is the more consequential change to watch over a longer horizon, because a reviewer that can run the test suite is verifying something a diff alone leaves open.

Claude Code 2.1.269–2.1.276: eight releases, mostly gateway and policy plumbing

Claude Code published versions 2.1.269 through 2.1.276 between September 11 and September 18. 7 8

The gateway work is what a platform team will recognize. Request headers now carry the request class, agent type, previous tool durations, and compaction state to an LLM gateway when CLAUDE_CODE_GATEWAY_HINT_HEADERS=1 is set, which gives a gateway the signals it needs to route and account for traffic it did not originate. 7 The modelPricing managed setting and the gateway's own pricing block accept a multiplier up to 10, so an internal chargeback rate can carry a markup. 7 Gateway sign-in now names the signed-in account for confirmation and shows it in /status, and a 400 error that broke every request behind a proxy or gateway was fixed the next day in 2.1.276. 7

Plugin and skill lifecycle changes matter to anyone who ships internal tooling on Claude Code. claude plugin eval runs a plugin's evaluation suite and returns scored, reproducible results as JSON and an HTML report. 7 /plugin install accepts a --marketplace flag that offers to add the marketplace first, and claude plugin install and update accept --accept-command <sha256> so an approved command can be replayed exactly. 7 Plugins installed from an npm source are now fetched with npm pack --ignore-scripts and integrity-verified, which keeps a package's install scripts from running at install time, and plugin and marketplace messages no longer echo credentials embedded in git, ssh, or marketplace URLs. 7 Skills and plugins enabled on a claude.ai account now sync into terminal sessions signed in with that account, with syncClaudeAiSkills and syncClaudeAiPlugins to opt out. 7

Sandbox and policy behaviour changed in ways that are easy to miss until an audit. Sandboxed Bash, PowerShell, and Monitor commands in auto mode carry per-command allowed_domains, so the hosts a command needs are reviewed with that command and opened for it alone. 7 A deny or ask rule beginning with ! now applies only within the settings source that wrote it. 7 Managed MCP settings supplied through MDM or managed-settings.json keep exclusive control when server-managed settings are also present, and a cached organization policy refreshes when the credential changes mid-session. 7

Three runtime knobs are worth knowing before a large rollout. CLAUDE_CODE_WORKFLOW_MAX_CONCURRENT_AGENTS raises the per-run concurrent agent limit for inference-bound fan-outs to as much as 256. CLAUDE_CODE_MCP_STARTUP_WAIT_MS bounds how long a first non-interactive turn waits for connecting MCP servers. 7 And the telemetry surface gained a claude_code.managed_settings_resolved event recording which managed-settings sources applied and which policy helper ran, which is the event to check when a policy that should have reached a machine appears not to have. 7

Exact release timestamps sit on the project's GitHub releases page, which is where the September 11–18 sequence can be confirmed version by version. 8

JetBrains Junie: a demo video for the diff, and a local model that thinks less

Junie CLI gained a /demo mode on September 18. You describe what to check, and Junie builds and launches the app, drives its interface, and returns an HTML report with screenshots and a video that opens with a slide introducing the scenario and closes with a results slide. 9 The same mode runs in CI through junie --demo, and JetBrains published two adaptable workflows, one triggered by pull requests and one for release smoke tests. 9

The usage figures come from JetBrains' own repositories: more than 1,500 unique pull requests and over 2,100 demo videos from the PR workflow, plus more than 1,300 smoke tests across internal release branches. 9 A demo run keeps your active model when it supports computer use and otherwise picks in the order GPT-5.6 SOL, GPT-6 Astra, GPT-5.5, then GPT-5.4, always at High reasoning effort. 9 Over a 22-scenario internal comparison, JetBrains reported GPT-5.6 SOL as both fastest and cheapest, at $19.94 for the full set in the provider's own subscription conversion; that measurement covers their scenarios and their prompts. 9 Configuration lives in a Dockerfile per environment with build and launch steps in .junie/demo.md, and both are documented. 17

Junie Local shipped a second change the same day. Its first release asked users to choose between Qwen3.6, fast enough for a laptop with reasoning disabled, and Qwen3.8, which solved more tasks but took roughly four times as long with reasoning enabled. 10 The new release merges the two into Qwen3.8-3.6-27B-blend and makes it the model for this version. 10 The merged weights are published on Hugging Face. 18

On JetBrains' 100-task internal coding benchmark the blend completed 37 tasks, against 34 for Qwen3.6 with reasoning disabled and 39 for Qwen3.8, while generating 71% fewer output tokens than Qwen3.8. 10 Across four LiveCodeBench runs it averaged 85.47% correct against 83.29% for Qwen3.8 and 67.87% for Qwen3.6, and on the 30 tasks that both the blend and Qwen3.8 completed, the blend generated about 70% fewer tokens — 279K against 935K. 10 These are vendor-run benchmarks on the vendor's own task set.

Two implementation details matter to anyone running local inference. Multi-token prediction proposing two tokens per round made decoding 60% faster than running without it on an M5 MacBook Pro, while proposing four dropped the gain to 36% because the extra GPU work outweighed the accepted tokens; the team kept the four-bit MTP head after finding no consistent speed advantage in the eight-bit one. 10 The blend can still overthink when it struggles, and JetBrains recommends interrupting it and restarting with a narrower goal when it revisits an approach without new evidence. 10

Availability: M5 Mac users install the blend by running /local in Junie, and Windows users get experimental NVIDIA RTX support in the nightly build, covering RTX cards from Ampere onward with at least 24 GB of VRAM. 10

Scatter plot of tasks completed against output tokens for Qwen3.6 with reasoning on and off, the merged blend model, and Qwen3.8 — JetBrains' own plot of coding quality against generation cost on its 100-task internal coding benchmark: the 50/50 blend at 37 solves and 1.37M output tokens, Qwen3.8 at 39 solves and 4.75M, and Qwen3.6 with reasoning off at 34 solves and 0.89M. 10

Kiro IDE 1.1: agent artifacts and native ARM64 builds

Kiro shipped IDE 1.1 on September 14. 11 Agent output — documents, diagrams, code, images — is now kept as durable artifacts that can be revisited: a compact preview appears in the conversation, the full artifact opens beside the chat in Agent Focus, and it can be reopened from the Agent Focus context panel. 11

Two platform changes arrive with it. Native ARM64 builds are available for Windows and Linux, so those machines stop relying on x64 emulation, and the editor foundation moved to Code OSS 1.131. 11 The same release notes list compacted conversations retaining the right context, clearer MCP failure messages, more reliable hooks, and enterprise profiles routing requests to the selected region. 11

The region-routing line is the one to confirm with the vendor before an enterprise rollout, since it is the only statement in this release that touches data residency.

Devin: voice, plugin scopes, and where MCP secrets live

Devin's September 16 release notes are long, and three items deserve a tooling owner's attention. 12

The first is secrets. MCP server credentials moved out of the general secrets page to each server's own page, with the old surface pointing there. 12 New secrets default to Personal for non-admins, and creating or importing an organization secret asks you to confirm that everyone in the organization can use it. 12 The same release added 21 one-click OAuth MCP servers, including Dropbox, ClickHouse Cloud, Railway, Retool, and Smartsheet. 12

The second is plugin permissions. Plugins bundle skills, rules, hooks, and MCP servers, and the marketplace now lives in the Customize page with one list across scopes; plugins your organization or enterprise requires show as read-only "Required by organization" or "Required by enterprise" sections, and install approval cards in the worklog name the marketplace, summarize the contents, and link to the item before you approve. 12

The third is review behaviour. Devin Review now always checks for security bugs in every review and the "Security scan" setting was removed, though whether those findings are posted to GitHub remains a toggle. 12 Review summaries were shortened to a behavior-focused paragraph with up to five bullets, and each finding gained an optional plain-language explanation, example, and recommended fix. 12

Other changes in the same release: Live Voice Mode puts voice calls on a live speech model with in-order transcript replies; sleeping sessions begin waking as you type in the composer; a session that loses its VM offers "Reboot VM" in the sidebar; and the v1 Sessions API accepts an idempotency_key, so a retried creation returns the original session and an in-flight one returns 409. 12

The September 11 notes added PagerDuty as a trigger source and an oncall responder that triages incidents and posts its investigation as incident notes, a Jira site picker for accounts belonging to more than one site, a GitLab "Automation scope" setting that lets organization admins allow automations on public-visibility projects, and a "Continue in a new session" path after a machine failure that warns machine-local files and running processes do not transfer. 12

Monitored this week, no release found

Five tools on this channel's watch list published nothing inside the September 11–18 window on the routes checked, and one release had not yet appeared when the cutoff passed.

Cursor: the newest entry on the official changelog is still Projects, dated September 10, which this channel covered in its previous issue. 19
Windsurf JetBrains plugin: the JetBrains Marketplace versions page lists 2.12.27 with an update date of August 18, 2026 20, and the plugin's own changelog page shows the same version dated August 17. 21
Aider: PyPI's newest aider-chat upload is 0.86.2, from February 12, 2026 22, and the newest tagged release on GitHub remains v0.86.0 from August 9, 2025. 23
Continue.dev: the GitHub releases page and the Open VSX listing both show v2.1.0 with a timestamp of June 19, 2026. 24 25
Replit: the newest post on the company blog is dated September 10, before this window. 26
GitHub Copilot weekly roundup: the roundup for the week of September 14 had not been published when the cutoff passed; that post is where the smaller Copilot changes are collected in a single entry each week. 27

Editorial view

Two clusters stand out in this week's releases, and each is held together by a shared mechanism rather than by the calendar alone.

The first is that control over model choice moved closer to control over money. Copilot's three tiers put a cost-versus-quality setting in front of each team, budget increase requests send an overrun to whoever pays, and Claude Code's gateway work lets a gateway see request class, agent type, and compaction state while its pricing configuration can carry an internal markup of up to 10×. All three assume the same thing: the unit of spend is a single model call, so the moment the model is chosen is the moment spend is decided. That is my reading of the releases, not a claim any of the vendors made this week.

The second is that several vendors shipped ways to inspect an agent's work. Copilot's reviewer gained shell tools, an ensemble, and self-resolving comments; Junie records a video of the feature it exercised and can run that check in CI; Kiro keeps agent output as artifacts. The measurement releases fit the same pattern applied to people rather than to code: feature engagement on the Copilot impact dashboard and the customization counts in its CLI reports both answer the question of whether a capability is being used.

Most of the figures behind both clusters are vendor measurements of vendor products: GitHub's addressed-comment percentages and its 8% cost reduction, JetBrains' benchmark results and its $19.94 test run. None of the releases in this window carries a breaking change that forces a migration, so the practical question each item raises is which of them is worth a deliberate test before the next budget or access review.

Worth doing before next Friday

Set the Copilot auto tier per team and the budget-request reviewer per paying organization in the same change, so a tier change cannot quietly raise spend.
Enable the Copilot usage metrics policy and pull one 28-day feature-engagement report, then compare it against what the enablement budget was meant to buy.
Run claude plugin eval against one internal plugin to see whether its score is stable enough to gate a release.
Wire one /demo scenario into CI on a single repository and read the report before adding more.
Confirm where MCP credentials now live in Devin's settings, and who can install or require plugins, before the next access review.