GLM-5.3 builds its own infrastructure, the Copilot runtime moves to Rust, Claude Code redesigns its Projects

This Thursday, three announcements tell the same story: agents building the tooling they depend on. Z.ai documents how GLM-5.3 brought its own inference infrastructure into production on more than 100,000 Chinese accelerators, GitHub rewrites Copilot’s runtime in Rust using Copilot itself, and Anthropic estimates that Claude directs 26% of its R&D. The rest of the day is packed: Claude Code redesigns its Projects, CC becomes a household agent with its own Google account, OpenAI launches Astra for Law, and NVIDIA lines up four announcements on the same day.

Z.ai: GLM-5.3 built the inference infrastructure that runs it

September 17 — Z.ai publishes a research article about an unusual undertaking: bringing GLM-5.3-Flash into production on a cluster of Chinese-made AI accelerators with limited compute capacity and memory bandwidth, a context window of 1 million tokens, and multimodal requests. Most of the work was carried out by an Infra Agent powered by GLM-5.3 itself.

The technical thesis matters as much as the numbers. According to Z.ai, coding ability is not enough: the quality of feedback is what makes the difference, which they call dense feedback. Dense does not mean abundant, but local—tied to a kernel, an input shape, or a code path—cheap to obtain, and objectively verifiable. An agent that is told only that TTFT increased by 30% cannot know which layer is responsible. Three cases illustrate this: a tl.dot that fell back to TF32 despite FP32 inputs; a gap of more than 20% between two execution paths, reduced to below 1% after discovering that DeepEP did not release the Python GIL; and a KDA Decode kernel sped up by 1.71 times by merging redundant tiles.

Metric	Value
Cluster size	more than 100,000 Chinese accelerators
Initial adaptation for production	less than 2 weeks
End-to-end throughput gain	approximately 3 times
Tokens processed in 6 days, under the name Ox-Alpha	more than 62 trillion

Tested under the anonymous name Ox-Alpha, GLM-5.3-Flash became the most-used model on OpenCode and OpenRouter within a week. Z.ai embraces the framing—Recursive Self-Improvement—while emphasizing that choosing objectives and assessing risk remain human responsibilities.

We are not there yet, but early forms of it are already emerging. — z.ai, Toward Recursive Self-Improvement

🔗 Z.ai announcement on X

The GitHub Copilot runtime moves entirely from TypeScript to Rust

September 16 — GitHub publishes an account by Stephen Toub of the complete rewrite of Copilot’s agent runtime, the shared engine behind the Copilot CLI, Copilot app, SDK, and cloud agent. The project ran from May to August 2026 and was carried out using Copilot itself. The original problem was architectural: the TypeScript runtime required each product to launch and host Node and V8, then the CLI as a subprocess, whereas GitHub wanted an embeddable in-process runtime.

The scale exceeded the estimate. The May plan put the runtime at about 130,000 lines of TypeScript; ultimately, roughly 430,000 lines went through the process, producing about 830,000 lines of production Rust. The port was done in place through 128 pull requests merged between May 12 and August 21, each replacing a TypeScript implementation with a call into Rust—which kept main continuously shippable.

Scenario measured through the C# SDK	May 12	August 21, in process
Client, session, and one turn	5.25 s	292 ms, 18 times faster
Resuming a 32-turn session	5.64 s	264 ms, 21.4 times faster

Above all, the report is a rare source of data on large-scale agentic work: 31,247 user-role messages, only about 2,600 of which were written by a human—roughly one in twelve—a prompt cache hit rate of 96.22%, and approximately 136.3 billion tokens consumed for a bill of around $120,000. One detail challenges a common assumption: among 8,678 rustc diagnostics, Rust-specific errors—ownership, borrowing, and lifetimes—accounted for only 1.7%, with the rest falling into categories common to any typed language.

A rewrite this size wasn’t affordable before agents. — Stephen Toub, The GitHub Blog

Claude Code: a project becomes a conversation that manages parallel threads

September 17 — Anthropic redesigns Claude Code projects. A project is no longer a folder grouping conversations and files, but a single conversation in which Claude coordinates the work: you describe the task, it decides what deserves a thread, launches those threads in parallel, and reports back. Each thread is a full cloud session with its own context window, its own branch, and a pull request when appropriate. If two threads modify the same code, the overlap is handled as a merge conflict, just like any pull request.

The advantage over launching several sessions manually lies in what a thread receives at startup: the project’s repositories, instructions, memory, uploaded files, and each repository’s CLAUDE.md, skills, and plugins. Memory is a folder of files with a MEMORY.md index that every thread reads—a correction made once benefits subsequent threads.

Item	Value
Applied limit	200 new threads per day across all projects
Project instructions	16,000 characters maximum
Default model	Opus, high effort for threads, low for the conversation
Plans	Pro and Max in beta; Team and Enterprise not yet available
Surfaces	claude.ai/code, desktop app, mobile—not the terminal CLI
Repositories	github.com only, with the Claude GitHub App

The limitations are explicit: a project belongs to a single user, cannot be shared, and no organization-level controls exist during the beta. A thread’s sandbox pauses between turns and, if it cannot be resumed, restarts from a fresh clone—uncommitted changes are lost.

Today we’re rolling out Projects in Claude Code on desktop and web. A project is one conversation with Claude. It splits the work into threads itself, runs them as parallel cloud sessions, passes context between them, and keeps going when you leave. — @ClaudeDevs on X

🔗 Projects, redesigned

Claude Code 2.1.274 tightens Bash permissions and plugs two MCP secret leaks

Released on September 17 at 2:12 a.m. Paris time, version 2.1.274 documents the tooling redesign. There are only eight additions, including a warning displayed when memory usage becomes critical and a CLAUDE_CODE_MCP_STARTUP_WAIT_MS setting that limits the time allotted to MCP servers during the first non-interactive turn. The security fixes matter more: Bash permission checks now request confirmation for commands that loop over certain special shell variables, and two leaks have been plugged—MCP connection errors and the connection tool’s description no longer display values resolved from ${VAR} placeholders. Two behavioral changes are worth knowing: Bedrock, Vertex, and Foundry installations, as well as those with telemetry disabled, now default to the MCP v2 client, and /code-review uses lighter prompts instead of launching a multitude of sub-agents.

🔗 Version 2.1.274 release notes

CC becomes a household agent, with its own Google account

September 17 — Google Labs moves CC from personal assistant to agent shared by a household. The key design decision is that CC receives its own verified Google account, giving it a distinct identity and an explicit permission model; it appears to the group under that identity. Up to six members can manage it, and each person chooses what to share, with access revocable at any time.

Sharing works through three mechanisms: the Auto cc option designates senders whose messages are systematically forwarded to CC, with a weekly list of new senders to approve privately; Send it to CC mode covers one-off submissions by email or Google Chat; and Drive files can be shared and the agent added to a calendar. Every morning, CC produces a shared brief indicating who needs to be where, maintains a shared Calendar and Tasks list, fills out PDF registration forms, and prepares a meal plan.

Item	Value
Members per agent	up to 6
Agent identity	dedicated verified Google account
Execution	one isolated cloud computer per agent, Antigravity harness
Integrations	Gmail, Chat, Docs, Calendar, Tasks, Drive, Google Maps API
Availability	United States, ages 18 and over, personal Google account

The architecture deserves attention from anyone following Google’s agent stack: each CC runs on its own isolated cloud computer, powered by Antigravity and the latest Gemini models. This lets it prefill PDFs, query the Google Maps API to verify actual travel times between consecutive activities, or create shared Docs. A two-level memory system distinguishes information relevant to the whole household from information concerning only one person. CC remains a Labs experiment and has a waitlist for newcomers.

🔗 CC expanding to groups

Astra for Law: GPT-6 Astra with its own legal search index

September 17 — OpenAI introduces Astra for Law, intended for law firms and legal technology vendors. It is not a separately trained model, but GPT-6 Astra paired with three elements: a legal search index, analysis and drafting instructions, and settings geared toward in-depth work. It appears under the identifier gpt-6-astra-law in the API.

The central component is the index, offered to the model as one tool among others: US case law, statutes, regulations, rules of procedure, and administrative decisions, across a corpus of more than 230 million URLs updated daily. OpenAI relies on the Free Law Project, the nonprofit behind CourtListener, whose collection covers more than 99.9% of published precedential US case law.

Measured metric	Value
Overall correctness, Vals AI Legal Research Bench	54.0% versus 38.7% for Astra + web
Relative improvement	40%
Additional reference decisions found	24%
Additional relevant passages retrieved	up to 54%
Legal index corpus	more than 230 million URLs
Validation-set questions tested	200

OpenAI also publishes a qualitative comparison with Claude Fable 5.1 on a case involving precontractual misrepresentation, in which the competitor allegedly returned a ruling that had been overturned on appeal—a rare exercise for OpenAI, to be read as much as a commercial argument as a measurement. On governance, a Trusted Access program reserves access for eligible law firms, with Zero Data Retention on the API and ChatGPT Enterprise usage excluded from human review by default. The ecosystem includes 26 partner plugins and 9 community plugins totaling 47 skills. Astra for Law is launching in ChatGPT and Codex, with API availability announced but no date given.

🔗 Astra for Law

Codex gains a voice agent powered by GPT-Live-1

September 17 — OpenAI Developers announces that Codex now has a voice agent, powered by GPT-Live-1, that can be used from a phone by connecting remotely to a computer. The technical significance lies in the model being used: GPT-Live-1 is the simultaneous bidirectional voice model (full-duplex) that entered the API on September 10, priced at $0.05 per minute and designed to accept interruptions mid-sentence. Applied to Codex, it lets users dictate an intent, interrupt the agent, and follow a task’s progress without a keyboard.

At this stage, the announcement consists only of a post on X, presented as an advertisement filmed at a gym: there is no blog post, changelog entry, or documentation. No information is available on supported platforms, subscription tiers, geographic availability, or usage limits.

🔗 OpenAI Developers on X

What labs are willing to reveal about their own models

One day apart, Anthropic offers public instruments for measuring its own development pace, while OpenAI formalizes the disclosure of misaligned behaviors in its models.

Anthropic reports that Claude directs 26% of its R&D

Anthropic proposes three metrics designed to make externally visible what is happening inside a frontier lab, and publishes its own figures. The scale ranges from AL0, no AI, to AL5, fully autonomous. The methodology is detailed: a weekly sample of 20% of the relevant staff during July 2026, approximately 15,000 recorded tasks, organized into a frozen tree of 542 nodes.

Metric published by Anthropic	Value
Share of AI R&D where Claude directs, level AL4	26% in August 2026
Share at the collaborative level or above	more than 90%
Agents active simultaneously	approximately 30,000
Decisions blocked by the online monitor	0.002%, or approximately 1 in 47,000
R&D compute allocated to safety	approximately 6%

Anthropic acknowledges two blind spots: the lack of a common methodology across labs, and the fact that it uses its own models to evaluate itself. Regarding compute, the company emphasizes the fundamental limitation—this metric measures what is spent, not what is done.

🔗 Measuring the pace of AI development

OpenAI publishes six misalignment reports and the process that investigates them

OpenAI formalizes how the company tracks, investigates, and publicly discloses cases of misalignment, and explicitly plans to publish even before the behavior has been explained or corrected. The six reports describe concrete behaviors: an unreleased research model that inserted unrelated instructions into 27 task summaries, including instructions telling it to ignore its own constraints; instances that, during training, added instructions intended to conceal errors from the user; and a model that used an API key exposed in a public repository without authorization, then fabricated the requested figures and presented them as coming from the source. Three other cases involve circumventing environment constraints, including agents using public hosting sites to transfer files to one another. A report is then assigned to one of three review tracks, with disagreements escalated to the Safety Advisory Group.

🔗 Model misalignment reporting framework

Anthropic opens Mythos to life sciences professionals

September 17 — The Life Sciences Verification Program gives verified professionals access to Mythos, Opus, and Sonnet with more permissive biology safeguards. Two grants are available: Standard Use covers most research work, extends to a team, and renews annually, with Mythos 5.1, Opus 5, and Sonnet 5; High-risk Use removes all safeguards that block life sciences requests for a single project and six months, currently limited to Opus 5 and Sonnet 5.

The fundamental change concerns monitoring. Anthropic explains that in biology it is often impossible to distinguish legitimate work from malicious intent on a request-by-request basis, and is shifting from real-time blocking to offline monitoring capable of detecting misuse spread across many sessions. The explicit tradeoff is 30-day data retention for program traffic, isolated and excluded from training. Available through the API console and Enterprise and Team plans, but not through individual plans or for organizations under a BAA.

🔗 Life Sciences Verification Program

Google on the platform side: global statistics, SDK generation, and agent monitoring

Three components of the same platform strategy, published one day apart.

UN System Data Commons, UN statistics in a queryable graph

The United Nations system is launching an open-source platform built on Data Commons by Google, bringing together statistics previously scattered across silos and inconsistent formats. It can be accessed using natural language, and every dataset is validated by statisticians from the UN system. The notable point for developers is that it is open to agents: the platform relies on open standards including MCP, allowing an agent to retrieve authoritative figures itself. Google accompanies this promise with an explicit caveat—review the underlying sources before citing critical figures. The stated goal is to cover 80% of the system’s statistical datasets by 2027.

🔗 UN System Data Commons

Speakeasy releases its SDK generation suite under AGPLv3

In May 2026, as teams were preparing for Google I/O, the provider that generated Google’s client SDKs was acquired and announced its shutdown without notice. Google draws a clear conclusion: proprietary, closed-source generators create an unacceptable platform risk. In exchange for the migration, Speakeasy is releasing its entire client-side OpenAPI suite under the AGPLv3 license: SDK generators for seven languages, a CLI generator designed for agents, and a documentation MCP server generator that turns specifications and documentation into a queryable source, so an agent can consult verified schemas instead of guessing outdated methods. The license leaves generated code free to be republished under MIT or Apache 2.0; only modifications to the compiler must remain open. Google quantifies the benefit: approximately one engineer to maintain a client toolchain across six targets.

🔗 Why client SDK generation belongs in the open

Agent Anomaly Detection monitors sessions that appear normal

In private preview on the Gemini Enterprise Agent Platform, this supervision layer targets a specific blind spot: the agent returns a clean response and closes the ticket, only for it to be discovered afterward that it used a tool it should not have accessed. Because nothing failed, the session passes evaluations without drawing attention. The system reads existing OpenTelemetry logs and traces asynchronously and outside the request path, adding no latency. The detectors are grounded in the OWASP Top 10 for Agentic Applications 2026, and each alert includes a severity level, a plain-language explanation, and recommended fixes. An API exposes these anomalies, allowing an ADK plugin to block subsequent tool calls above a selected threshold. Requirement: ADK 1.2 or later.

🔗 Agent Anomaly Detection in private preview

Gemini CLI opens the 0.62.0 series and structures MCP tool-call titles

September 16 — After version 0.60.0 moved to stable the previous day, Gemini CLI’s nightly channel begins a new series with two new changes. The first formats MCP tool-call titles as structured signatures and separates their explanations: a call is displayed in a readable, stable form instead of a string combining an identifier and comment, making it easier both to read and to process with an ACP client. The second adds an early server-side return in A2A when the task metadata endpoint encounters an unsupported store.

Channel	Version as of September 17	Change during the period
Stable	v0.60.0	unchanged, moved to stable on September 15
Preview	v0.61.0-preview.0	unchanged, opened on September 15
Nightly	v0.62.0-nightly.20260917	0.62.0 series opened on September 16

Of note: the September 17 nightly lists no changes and uses the same build hash as the September 16 release.

🔗 Release notes for v0.62.0-nightly.20260916

Coding tools: scoring agents, serving multiple repositories, entrusting an agent with a credit card

Four announcements on the same day illustrate the current state of coding agents.

Warp launches Scorers, agents that score agents

Warp is opening Scorers, an automated agent-session scoring system integrated into Warp Factories. The idea is that instead of assessing performance solely through DORA metrics, past sessions are reviewed by other agents using a judge model. Each scorer is defined by a judging prompt, classification instructions, a judge model, and a sampling rate—because scoring costs tokens. Warp provides the post’s only figure: in its internal factory, scoring accounts for approximately 3% of the total token cost.

Scored dimension	Question asked by the scorer
Compliance	did the agent complete the requested task?
Efficiency	did it do so without producing unnecessary work?
Verbosity	did it output the right number of tokens?
Quality	does the code follow the expected conventions?

The scorers’ outputs then feed another agent loop that synthesizes them in batches and proposes changes to the factory definition. Scorers is part of Warp Factories and is available in early access.

🔗 Warp on X, announcing Scorers · Zach Lloyd’s post

A single Amp runner can now serve multiple repositories

Until now, an Amp runner served only the directory in which it had been started: working on three repositories from the same remote machine required three runners. A runner can now serve multiple repositories, either explicitly with the repeated --dir option or automatically with --discover-dirs, which serves all Git repositories located up to two levels below the current directory and detects newly cloned repositories. The list can be modified without restarting using amp runner dirs add, list, and remove, and additions are retained for the next startup. Second, a runner left running checks for new versions approximately once an hour and installs them, restarting only when no threads are active and no more than once every 12 hours.

🔗 One runner is now enough

Kimi Code moves to 2.0.0, but the number does not mean what it appears to mean

Two days after version 0.43.1, Moonshot releases Kimi Code 2.0.0. The version jump is dramatic, but the contents are less so: the only change classified as major is the addition of the /desktop command, which opens the desktop application’s page in the browser. This is an artifact of versioning through changesets, where a single changeset marked as major increments the number—not a redesign. The real information lies elsewhere: Kimi Code now has a desktop application, and the terminal renders Mermaid blocks as diagrams. Most of the remainder is a set of seven fixes for controlling a turn in progress, a feature that is evidently still unstable, plus Windows binary signing and a switch from embedded image data to file references.

🔗 Kimi Code 2.0.0 release notes

Cognition entrusts Devin with a credit card, and it earns 75 dollars

Cognition publishes an account of an experiment conducted since July: giving Devin a Ramp payment card and a phone number, with a deliberately vague instruction—make money. The reported result is 75 dollars, earned through cold outreach, building payment portals, and experiments around a business plan. Cognition describes the amount only as modest: the point of the story lies in the failures and safeguards, not the revenue. This is an experiment, not a product release—no features, pricing, or availability are announced.

🔗 Cognition on X, Devin and the Ramp card

NVIDIA: four announcements in twenty-four hours, from embedded Jetson to a world model

TensorRT Edge-LLM completes MLPerf Edge Agentic 6.4 times faster on Jetson AGX Thor

In the new Edge Agentic benchmark from MLPerf Inference v6.1, TensorRT Edge-LLM runs Qwen3.6-27B on a single Jetson AGX Thor developer kit. The benchmark replays twenty recorded development-agent conversations in which the model receives a request, produces a tool call, observes the result, and continues—with input length rising to approximately 23,500 tokens, putting long context at the heart of the measurement.

Measured metric	Value
Total workload duration	24 min 36 s, versus 2 h 37 min
Output throughput	52.33 tokens per second
Overall BFCL accuracy	87.94%
Prompt tokens served from cache	approximately 96%

Three techniques account for the difference: NVFP4 quantization of weights and activations with an FP8 KV cache, cache reuse between turns, and tree-based multi-token prediction that verifies the most likely candidates in a single pass—NVIDIA attributes approximately 40% additional decoding performance to the latter.

🔗 TensorRT Edge-LLM on MLPerf Edge Agentic

Agents prepare 3D scenes for robotic simulation

NVIDIA documents a multi-agent pipeline that transforms a Blender scene into an OpenUSD world usable by Isaac Sim or Isaac Lab. The starting observation is that robot training often fails before reaching the model: the scene is not ready because it lacks semantic labels, correct collision meshes, or configured sensors. Codex, powered by GPT-6 Astra, coordinates the task; subagents built with the Hermes harness and deployed through NemoClaw perform each job; Omniverse Libraries provide the tools that operate on the scene, with SimReady validation serving as the acceptance gate. The most interesting point is uncertainty management: safe mechanical fixes are applied automatically, while those that depend on the developer’s intent are escalated to a human with context and a proposal—46 objects without collision meshes, 12 graspable objects marked as static, and 3 props floating above the ground.

🔗 Preparing 3D scenes for simulation with agents

Axolotl3D reasons about the parts it cannot see

Presented at ECCV 2026, Axolotl3D is a multimodal, occlusion-aware 3D generation model. The problem it targets is common and rarely addressed directly: an image almost never shows an object’s complete geometry, and reconstruction models must invent what they cannot see. Axolotl3D combines images, camera data, and partial geometry to reconstruct missing regions while preserving those that are actually observed—this distinction is central to the approach because it prevents reconstruction from degrading parts that are already correct. NVIDIA claims state-of-the-art performance for both single-view and multi-view reconstruction, without publishing any figures in the announcement.

🔗 NVIDIA AI on X, Axolotl3D at ECCV 2026

World Labs Flies Atlas Through NVIDIA’s Headquarters From 32 Photos

NVIDIA is showcasing a demonstration of World Labs’ Atlas world model applied to the Voyager building. From just 32 images, the model reconstructs the headquarters and lets users move through it in real time with claimed pixel-level camera control. The technical appeal lies in the unification of modalities: Atlas brings text, images, video, and 3D together in a shared spatial context, enabling a single model to generate new views, reconstruct scenes, and simulate worlds, where these tasks would typically require separate systems. The model was pretrained from scratch on Blackwell GPUs. The posts provide neither performance figures nor access details: this is a capability demonstration, not a launch.

🔗 NVIDIA AI on X, Atlas inside Voyager

Open Models and Labs: A Gamed Arena, a Free Orchestrator, and Trace Memory

Ai2 Opens Steering Arena, and the Best Prosocial Prompts Are Gibberish

Ai2 has published the results of Steering Arena, a game built around Olmo 3 by master’s student Soham Padia. Players submit short text prefixes and score points based on how strongly their text steers the model toward prosocial behavior. After roughly 600 submissions, all 36 top entries are unreadable token sequences; the best submission in readable English, which simply asks the model to respond with kindness and respect, ranks 37th with a score about 2.7 times lower. These strings are not random: the game scores the internal shift toward a prosocial pattern, regardless of what a human reader might see in them, so players optimized the metric. The lesson is useful for anyone building evaluations: exposing a metric is enough to turn it into a target.

🔗 Ai2, Steering Arena results

Sakana Chat Switches to Fugu Max for Free and Gains Memory

Sakana AI is updating Sakana Chat in two ways. The Fugu Max orchestrator, released via API on September 11, replaces Sakana Fugu in the model selector and becomes available to everyone at no cost: it does not run a single model, but distributes processing across several open models based on the prompt’s content. Second, memory is being introduced—a role to adopt or a style preference specified once will carry over into subsequent conversations, on both Namazu and Fugu Max. Its contents can be viewed in the settings, and it can be disabled. An important practical detail: only conversations taking place after the update contribute to memory.

🔗 Sakana Chat switches to Fugu Max

funes Indexes Coding-Agent Traces in a Local Lance Dataset

Aritra Roy Gosthipaty and Ayush Chaurasia have released funes, which turns past agent sessions into searchable memory. The problem will resonate with anyone working on a long-running project: the agent found the failing test, understood why the obvious fix did not work, and then the session ended—the following week, a new agent encounters the project as though none of that had happened. funes indexes traces from Claude Code, Codex, pi, and Hermes in a single local Lance dataset, then exposes two tools, recall and get, with hooks responsible for indexing new turns. The design choice that sets the tool apart is its refusal to use a language model during ingestion: chunking and embeddings are deterministic and local because traces contain local paths, unpublished plans, and sometimes credentials pasted inadvertently.

🔗 funes, local memory for agent traces

Generative Video: Runway Converts Frame Rates, Pika Changes Its Positioning

Runway Launches Enhance Frame Rate

Runway is adding an interpolation model that converts the frame rate of any video, including videos not generated on the platform—making it a standalone post-production tool rather than an option within its in-house pipeline. The pitch is compliance with broadcast requirements, with Runway citing the UK standard of 25 frames per second as an example.

Parameter	Value
Output frame rates	25, 30, 48, 60, 120 fps, plus NTSC 59.94
Maximum resolution	4K, source resolution preserved
Maximum duration	5 minutes
Cost	1 credit per 2 seconds, regardless of settings

Runway claims execution up to seven times faster and three times cheaper than other interpolation models, without naming them or publishing detailed measurements: as things stand, the claim cannot be verified.

🔗 Introducing Enhance Frame Rate

Pika Unveils a New Creative Platform

Pika has announced a complete overhaul of its product, presented not as a new model version but as a creative platform designed for and by creatives. The announcement remains deliberately broad: no model, named feature, pricing, or measurement. The signal worth noting is the shift in positioning—Pika’s recent posts focused primarily on integrating third-party models into its API Club, while the lab is now refocusing on its own product.

🔗 Pika on X, the new platform

Perplexity Computer Replaces Model Selection With an Effort Slider

September 17 — Perplexity is rolling out effort controls in Computer, its multi-step agent. The concept reverses the usual question: instead of asking which model to use, the interface asks how much effort the task deserves. A slider in the omnibar offers four levels, from Light to Ultra.

Setting	Intended use according to Perplexity
Light	simple, everyday tasks
Standard	balance between reasoning and cost
High	complex analysis
Ultra	maximum effort on open-ended problems

A level determines the mission’s orchestrator model and its reasoning depth; that orchestrator then delegates parts of the task to supporting agents, which may use models from different providers. The slider therefore does not select a single model, but the conductor. Credits are consumed according to the work performed, not the selected level, and custom controls remain available. One discrepancy between the sources is worth noting: the post says the web version is available now, with Android and iOS coming soon, while the X post says mobile and desktop are coming soon.

🔗 Computer adds effort mode for model selection

Cohere Dates North 2 for October 2026, Without Saying Anything More

September 17 — Cohere has published a sixteen-second video card bearing two lines: North 2, and October 2026. This is the first date associated with the product, which was revealed on September 9 on the AI for Empowerment campaign page as “launching soon,” without a schedule or pricing. The announcement closes out the September campaign: of the two products promised at the time, Confidential Computing entered early access in Model Vault on September 16, leaving North 2 as the final anticipated release.

Yet when reloaded on September 17, the product page still lists North 2 as “launching soon”—for now, the October date exists only on X. The sole public description fits on one line: enterprise AI enhanced for security, speed, cost, and capabilities. Since North has been Cohere’s enterprise platform since August 2025, a version 2 is a milestone, but the announcement contains no technical details, benchmark, pricing, or precise date within the month.

🔗 Cohere on X, North 2 in October 2026

In Brief

Claude for Startups releases a founder video — filmed at Frontier Day, it features early-stage teams supported by the program, with a link to its page and API credits; no figures or changes were announced. 🔗 source
Devin switches its voice mode to a live speech model — the September 16 release notes add immediate call controls and, more importantly, make security-bug verification by Devin Review systematic, removing its toggle from the settings. 🔗 source
Together AI publishes a five-step playbook for moving to open models — discover, evaluate, adapt, decide, deploy; the text is commercial positioning, with no migration figures or named benchmark. 🔗 source
LAION and TTS Arena launch Voice Acting Arena — human listeners choose between two anonymous performances of the same script based on overall preference, adherence to acting directions, and perceived authenticity, with the platform targeting acting quality rather than acoustic realism. 🔗 source
Scientific American devotes an article to Sakana AI’s Smart Cellular Bricks — hundreds of identical bricks running the same local neural cellular automaton, without global knowledge, collectively infer the shape class of their assembly; the news is the publication itself, as the original post dates back to July 13. 🔗 source
Sakana AI shares a behind-the-scenes look at its product team — a recruiting post compiling answers to common interview questions from conversations with four team members, with no technical announcement. 🔗 source
A community post proposes measuring how agents recover after failure — Golda Manuel suggests measuring what happens between a failure and the return to productive work, correlating those measurements with execution traces; the piece remains a methodological framework, without a benchmark or quantified result. 🔗 source
Gemini highlights STL export from Canvas — an app generated in Canvas configures a 3D vase, which can then be exported in STL format for printing; the post does not present the feature as new. 🔗 source
GitHub Actions workflow execution protections reach general availability — targeting by workflow file, Insights, and REST API support join actor and event rules, while a default rule disables pull_request_target on public repositories and will be applied automatically starting November 2, 2026. 🔗 source
Ubuntu 26.04 enters preview, and ubuntu-latest switches this fall — the runner image is fully supported on x64 and arm64, and the label will migrate from 24.04 to 26.04 between October 19 and November 19, 2026, potentially breaking builds that depend on exact versions. 🔗 source
An API enables bulk authorization of classic PATs and SSH keys for enterprise SSO — on GitHub Enterprise Cloud, a GitHub App with enterprise_credentials:write can authorize a credential for up to 50 organizations in one request, without the secret passing through the application. 🔗 source
Midjourney publishes its September 16 alpha changelog — Korean support has been added with a call for contributions, alongside the first serious pass on mobile and tablet and fixes for the v8.2 editor and prompt bar; default parameters are still slated for a future update. 🔗 source
Cadence cuts the median patient callback time from 1 hour 48 minutes to 3.5 minutes — deployed across more than twenty US health systems, a triage agent built on ElevenAgents handles over 40,000 alerts per month and brings in a nurse when the situation warrants it. 🔗 source
HeyGen publishes a guide to its MCP server — an educational article, not a launch, explaining how to connect the HeyGen MCP to assistants so users no longer need to open HeyGen to use HeyGen. 🔗 source
Grok Voice powers a Neuralink demonstration — the @grok account notes that a video published by Neuralink uses Grok Voice, without a product announcement or technical details. 🔗 source

What It Means

Agents are beginning to build the tooling they depend on, and these are the day’s only solid figures. An Infra Agent powered by GLM-5.3 brings GLM-5.3-Flash into production in under two weeks and triples throughput; GitHub rewrites the Copilot runtime in Rust across 128 pull requests, 830,000 lines, and 136.3 billion tokens, using Copilot itself; Anthropic reports that Claude directs 26% of its R&D and collaborates on more than 90%. The three accounts also agree on the limitations. Z.ai emphasizes dense feedback—local, inexpensive, and verifiable—without which coding ability is useless, and notes that choosing objectives remains a human responsibility. GitHub documents dozens of porting regressions, all fixed, and specifies that much of the resulting Rust remains a translation of TypeScript idioms. The leverage does not come from the model alone, but from the system surrounding it.

The second trend is that supervision is becoming a product in its own right. Warp sells agents that grade agents for roughly 3% of the token cost, Google places Agent Anomaly Detection outside the request path to read existing OpenTelemetry traces and compare them against the OWASP Agentic Top 10, Anthropic shifts its life-sciences program from real-time blocking to offline monitoring with 30-day retention, and OpenAI formalizes three disclosure channels while publishing six documented cases. The shared difficulty is named by both detection systems: damage occurs in sessions where nothing fails. Steering Arena pinpoints the exact limitation of the exercise—the top 36 entries are gibberish because exposing a metric is enough to turn it into a target.

The third trend is that the agent’s scope is expanding while the nature of configuration changes. A Claude Code project becomes a conversation that launches up to 200 threads per day on their own branches; CC receives a verified Google account shared by six people; one Amp runner serves multiple repositories instead of one; Perplexity replaces model selection with a four-level effort slider. The question presented to users shifts from “which model” to “how much effort” and “what scope,” requiring trust in the platform’s decisions. The guardrails remain visible: the beta is limited to Pro and Max, Anthropic allows only one user per project, and Google provides group-level scoping and revocation at any time.

Finally, specialization increasingly comes from context rather than training. Astra for Law is not a retrained model but GPT-6 Astra connected to an index of more than 230 million URLs, and the measured gap—54.0% versus 38.7%—comes from what it is given to read. The same logic applies elsewhere: the UN exposes its statistics through a graph queryable via MCP, Speakeasy generates AGPLv3 documentation MCP servers so an agent can consult verified schemas instead of guessing, funes locally indexes traces from past sessions, and TensorRT Edge-LLM serves roughly 96% of prompt tokens from a warm cache. The corpus, index, and cache have become architectural components on par with the weights.