Cursor launches Projects and its coordinator agent, GPT-Rosalind leaves research preview, Runway licenses its closed weights

Fifty-two announcements, most of them published on September 11, and the same idea keeps recurring among companies that do not coordinate with one another. Cursor entrusts an entire project to a coordinator agent that does not code and delegates to thousands of sub-agents, Cognition runs two models as a team on the developer’s machine, and Sakana routes each task to the lightest model capable of solving it. That same day, OpenAI took its life sciences model out of research preview with public pricing, Runway began licensing the weights of its closed models to enterprises, and Anthropic released a subcommand that finally measures what a plugin actually contributes.

Cursor launches Projects, projects managed by a coordinator agent

September 10 — Cursor launched Projects, an overhaul of how work is assigned to an agent in the editor. The product breaks with the practice established over the past two years: instead of opening a new conversation for each task and then closing it, the user talks with a coordinator agent in a thread that lasts for months. This coordinator does not write a single line of code. It directs other agents that do, leaving it continuously available to receive instructions while the work progresses.

Three mechanisms make this possible. First, cloud execution by default: a Project runs on its own machine, closing the laptop does not interrupt it, and the number of sub-agents running in parallel is no longer limited by local hardware. A local agent starts when a test needs to run on the developer’s machine. Next comes shared context: each Project maintains a set of files synchronized across all machines, where agents store their research, artifacts, and understanding of the code. If one discovers how to test a service, all subsequent agents have access to the procedure. The third mechanism is the most unusual. Cursor calls it subscriptions: the coordinator can monitor a Slack channel, run on a schedule, or track every pull request to repair continuous integration. The agent acts when it detects a signal, without waiting to be prompted.

Population measured	Measured effect on pull requests
New Projects users	30 percent more merged
Users working mostly in Projects	Six times more merged
Internal design system Project	20 to 100 pull requests modified per day, projected

The coordinator doesn’t write code itself but directs other agents that do. Because it delegates rather than executes, it is never blocked and is always responsive to direction. — Cursor, Projects blog

These figures are internal measurements and should be read with due caution. The most illustrative example remains gardening, Cursor’s name for work that never ends: an engineer runs a Project dedicated to the design system, which reviews every new pull request, extracts the components that belong in the system, and adds a lint rule whenever it sees the same mistake twice. Projects is in beta and has been rolling out gradually since September 10. The announcement mentions neither pricing terms nor plan restrictions.

🔗 Cursor announcement on X

GPT-Rosalind leaves research preview, with public pricing

September 11 — OpenAI Developers announced that GPT-Rosalind, its reasoning model dedicated to life sciences, is leaving research preview. Introduced on April 16, 2026 for biology research, drug discovery, and translational medicine, the model was initially available only to eligible Enterprise customers in the United States. It is moving to trusted access for eligible organizations worldwide through the API, Codex, and ChatGPT Enterprise, and this access will cover upcoming models in the series as they are released.

The API changelog, in an entry dated September 8, provides details not mentioned in the X thread. The model is called gpt-rosalind-research, and its general availability remains subject to the trusted access program, which is reserved for internal life sciences research approved by OpenAI.

Pricing or access item	Announced value
Model identifier	`gpt-rosalind-research`
Input tokens	5 dollars per million
Cached input tokens	0.50 dollars per million
Output tokens	25 dollars per million
Billing begins	October 5, 2026
Access surfaces	API, Codex, ChatGPT Enterprise
Access requirement	Trusted access program, eligible organizations

Billing does not begin until October 5: during the research preview, usage consumed neither credits nor tokens. On the tooling side, Codex’s Life Sciences plugins form the model’s orchestration layer, spanning genomics, protein structure, and translational research, from collecting biological evidence to generating quality-control reports and interactive notebooks. This package, released for free on GitHub in April, provides access to more than 50 public multi-omics databases, literature sources, and biology tools; it works with general-purpose models for everyone, but only eligible Enterprise users can combine it with GPT-Rosalind.

The performance claims remain those from the launch: the best published score on BixBench, an advantage over GPT-5.4 in 6 of LABBench2’s 11 tasks, with the largest gap on CloningQA, and, on an RNA sequence-function task designed with Dyno Therapeutics, a best submission above the 95th percentile of 57 human prediction experts. The concrete news is twofold: a specialized model leaving experimental status with public pricing, and a geographic expansion of access. Eligibility remains the barrier, as self-service access is not available.

🔗 OpenAI Developers thread on X

Runway Model Licensing delivers closed model weights to enterprises

September 11 — Runway opened a model licensing program for enterprises. The approach breaks with API access: the customer receives the complete weights of a latest-generation Runway model, fine-tunes it on its own data, hosts it within its infrastructure, and commercializes what it builds from it. Data and generations never leave the customer’s environment, explicitly targeting studios, brands, and governments.

Delivered item	Contents
Model weights	Complete weights as a starting point
Checkpoints	Multiple model versions to validate
Training script	Code for adding proprietary data and running fine-tuning
Delivery	Packaged into the customer’s codebase and hosted wherever it chooses
Deployed researchers	Hands-on assistance with configuration, weights, and delivery

Hosting can take place in the customer’s cloud, in its data center, or entirely on-premises, including in air-gapped environments for government agencies. Six sectors are named: software platforms; film and studios; brands and marketing; robotics and physical AI, with the World Action Model serving as the policy backbone; video games and 3D, with photorealistic enhancement of low-quality renders; and governments.

Economically, Runway distinguishes between two paths: Runway Dev, the usage-based API with no infrastructure to manage; and the annual license, with predictable costs and complete control over versions, behavior, and outputs. The FAQ addresses the objection of obsolescence: future models will not have access to the customer’s proprietary data, annual renewal is planned, and credits are provided for subsequent generations. It estimates the cost of rebuilding the technology internally at years of learning and hundreds of millions of dollars. The company presents itself as one of the very few in the world licensing closed weights of this quality and directly contrasts its offering with open weights, which it says deliver a weaker model accompanied by a to-do list. No pricing is published; access requires submitting a sales form. The announcement comes nine days after Runway Dev MCP and one week after the Team plan: Runway now covers the entire range, from individual creators to closed-weight licensing.

🔗 Model Licensing page

Cognition brings Fusion to Devin Desktop and Devin CLI

September 11 — Cognition announced the availability of Fusion in Devin Desktop and Devin CLI. The architecture had been running on Devin Cloud for several months; it is now coming to the developer’s machine. The announcement follows SWE-2, its in-house coding model, by one day, and the two are closely connected because SWE-2 is the recommended sidekick in the setup.

The principle is simple to describe. When choosing Fusion, users select not one model but two. A frontier model serves as the lead and remains in control of the session: it owns the plan, resolves ambiguities, and reviews the completed work. A less expensive model serves as the sidekick: it explores the code, writes the changes, runs the tests, and reports back. Both run in parallel, each with its own persistent context. The technical argument is aimed at model routing, the solution that naturally comes to mind for reducing costs: an initial prompt is not enough to assess a task’s difficulty, and switching models along the way breaks the prompt cache. Fusion avoids this problem by never transferring entire conversations between the two models, which exchange only briefs, results, and feedback.

Cost per task, in dollars	Fable 5.1 alone	Fusion Fable 5.1 and SWE-2	Astra alone	Fusion Astra and SWE-2
DeepSWE 1.1	14.63	7.88	7.88	4.69
Terminal-Bench 4	17.46	13.37	10.08	6.06
SWE-Atlas QnA	7.57	5.00	5.72	3.59
Vals Code Migration	70.97	42.00	44.36	35.51
Extended FrontierCode 1.1	2.68	1.67	2.62	2.34

One of our key findings is that using more expensive models can make the entire system cheaper. — Cognition, local Fusion blog

The case is made for both sides of the pair. On the lead side, replacing Opus 4.8 with Fable 5, which nominally costs twice as much per token, reduced the average session cost by 9 percent with the same sidekick, while achieving a better FrontierCode score: Fable delegated earlier and wrote better briefs, whereas Opus micromanaged its sidekick. On the sidekick side, moving from GPT-5.6 Luna to SWE-2, which costs 275 percent more per million tokens, reduced the total task cost by 2 percent while improving the score by 1.4 points. On the Artificial Analysis Coding Agent Index v1.5, Fusion with Fable 5.1 and SWE-2 scores 61.7 at 36 percent lower cost than Claude Code with Fable 5.1, which tops out at 62.2. Cognition derives a rule for 2026: evaluate models, and model-harness combinations, by cost per task rather than cost per token. It is a convenient position for a company selling a harness, but the figures were produced with Artificial Analysis and Vals AI across five separate benchmarks. Installation requires a single command.

🔗 Cognition announcement on X

Sakana AI Launches Fugu Max and Fugu Ultra v2, Two Evolutions of Its Multi-Agent Orchestrator

September 11 — Sakana AI is releasing Fugu Max and Fugu Ultra v2, two new versions of Sakana Fugu, its multi-agent orchestration system exposed behind a single OpenAI-compatible API. The guiding principle is the Pareto frontier: Sakana believes the industry still reasons as though capability were the only dimension, even though a real-world task is judged on two—capability and cost.

Fugu is not a single model but a learned orchestration layer that routes each task to a pool of open-weight and specialized models. Fugu Max expands this pool—the company’s largest to date—by integrating the NVIDIA Nemotron family, and sends each task to the lightest model capable of solving it. It achieves the best overall score on six benchmarks and extends the cost-performance frontier on seven out of ten, at 2 dollars per million input tokens and 6 for output, an output price that Sakana says is 40 to 60 percent below those of Sonnet 5, GPT 5.6 Terra, and Kimi K3.

Announced metric	Score	Comparison provided by Sakana
Fugu Ultra v2, Chartography	48,3	Opus 5 at 27,3; Fable 5 at 29,5
Fugu Ultra v2, DeepSWE	74,3	Ahead of models costing 3 to 5 times more per token
Fugu Ultra v2, ranking	1st or tied on 5 of 8 benchmarks	Top 2 on 7 of 8
Fugu Max, overall ranking	Best score on 6 benchmarks	Pareto frontier extended on 7 of 10

The point Sakana emphasizes most deserves attention: Fable 5, Fable 5.1, and GPT-6-Astra are not part of Fugu Ultra v2’s agent pool, whose training cutoff date is August 28, 2026. The argument is supply resilience: an interchangeable pool protects against vendor lock-in, API revocations, and service outages. Both models are available immediately, and a Fugu user switches to Max or Ultra v2 by changing a single parameter. Fugu Max is also listed on OpenRouter, with multimodal input, web search, configurable reasoning, and structured outputs. A caveat: the benchmarks and comparison models were selected by Sakana, SWEFish is an internal test bed, and the claimed differences depend on the pricing of the compared models at the time of publication.

🔗 Introducing Fugu Max and Fugu Ultra v2

ElevenLabs Launches Music v2.5, with Lossless Downloads on Every Plan

September 11 — ElevenLabs has released Music v2.5 and made it the default in ElevenMusic, for both prompt-based and audio-reference generation. The model claims instruments that sound like a live recording, deeper arrangements, longer compositions, mid-song genre transitions, rap, and vocals that sound native in the language of the lyrics. The cited measurement is a blind test of 47 885 pairs, with one take per model for the same prompt: Music v2.5 was preferred most of the time, with the clearest lead in vocal- and acoustic-driven genres—R&B, soul, hip-hop, rock, metal, orchestral, and film music. The exact preference percentage was not published.

The second part changes more for users. Every track created in ElevenMusic belongs to its creator on every plan, including the free plan. The free plan provides five lossless downloads per day with commercial use permitted provided ElevenMusic is credited, while the Pro plan provides 400 per month. Permissions acquired when a track is created remain attached to it: canceling or downgrading does not affect previously produced tracks, and any future change to the terms would apply only to new ones. The sole exception is a track built from another artist’s song, which cannot be downloaded.

Measured or announced item	Value
Pairs evaluated in the blind test	47 885
Lossless downloads, Free plan	5 per day, commercial use with attribution
Lossless downloads, Pro plan	400 per month
API identifier	`music_v2_5`
Default model in ElevenMusic	Music v2.5, with Music v2 retained

The model is also available in ElevenCreative, as a Music node in Flows, and in the API under the identifier music_v2_5. ElevenLabs specifies that the multiyear agreement announced the previous day with Universal Music Group is separate from this release. For readers, the order of the announcements matters: the agreement with the major label was announced first, followed the next day by the model and expanded usage rights.

🔗 ElevenLabs announcement on X

Claude Code Measures What a Plugin Really Adds, With and Without It

September 11 — The Claude Developers team has announced claude plugin eval, a Claude Code subcommand that runs a plugin or skill against a suite of test cases, scores each run, then reruns every case without the plugin to measure what it contributes. The idea is simple and somewhat uncomfortable: a high score does not prove that a plugin helps, since Claude sometimes performs just as well without it. The command therefore returns two scores and the difference between them. If a case scores 1.0 in both arms, the plugin had nothing to do with it.

The entry point is claude plugin eval init, run at the root of the plugin. An interactive session opens: Claude reads the plugin, asks what a good result looks like, suggests prompts that should and should not trigger it, designs the graders, pilots them once, writes one directory per case, and announces the estimated cost of a full run. Each case then runs three times with the plugin and three times without it—six runs in total—because a single run of a nondeterministic agent does not say much. The terminal displays a table with and without the plugin, a standalone HTML report is written to disk, and the report is published as a private artifact when the account supports it.

Grader type	Cost in model calls	Success condition
`regex`	none	Pattern found in the final response, trace, or a file
`tool_used`	none	Number of calls to a tool falls between a minimum and a maximum
`tool_order`	none	One call precedes another
`file_exists`	none	A file created during the run matches the pattern
`llm`	one model judges	Favorable verdict in at least 2 out of 3 votes
`baseline`	one model judges	The run is at least as good as a reference transcript

One subtlety must be understood before interpreting a difference: a grader that requires the skill to be called can never pass without the plugin, so it is excluded from the score in both arms and reported only as an indicator; otherwise, the gap would be artificially inflated. Isolation is strict. Every run is a disposable child process, without user settings, hooks, CLAUDE.md, an MCP server, installed plugins, or memory. Runs never ask permission questions, and sensitive tools are removed from the session unless explicitly authorized; if Bash or PowerShell is allowed on a machine without a sandbox backend, Claude Code refuses the run instead of executing it without containment. A plugin that communicates with MCP tools can be evaluated without the actual service, with one Markdown file per tool supplying the response and a block that aborts the run if the plugin sends anything other than expected.

Evals call the model, so they use tokens and results vary. […] Your plugin’s hooks and MCP servers run as you, so only evaluate plugins you trust. — @ClaudeDevs on X

The cost is real: every run and every judge grader is a model call charged against the plan or bill, with the documentation example showing 74 seconds and 0,41 dollar for one case of six runs. Hence the team’s guidance: pilot first with --runs 1 before starting a full run. For continuous integration, exit codes are documented, including 0 when everything passes and 2 for a partial run when the cost ceiling is reached. The typical first finding, according to the documentation, is a difference close to zero with the skill grader failing: Claude does not choose the skill when given natural phrasing, and its description needs to be revised.

🔗 Plugin evaluation documentation

The Rest of Version 2.1.269

The subcommand arrives in version 2.1.269, released on September 11 at 9:17 p.m. Paris time. The remaining additions are less conspicuous but useful in daily work. The /output-style command lists and changes the output style, including through Remote Control and in cloud or headless sessions. When the Bash tool is used to modify files, its result now includes the diff of changed files, giving Claude the same visibility as with a conventional edit. On the observability side, an environment variable labels OpenTelemetry metrics and events by repository, while two others configure the model-discovery timeout for a gateway and the Workflow tool’s concurrent-agent limit, up to 256.

The fixes affect three sensitive areas: partial prompt-cache invalidation after a response is interrupted and then resumed; permission rules beginning with a negation, which now apply only to the settings source that wrote them; and write-path verification, which finally covers the file written by a tee command. The git status reported after compaction is now the current one rather than the one from the beginning of the session. In VS Code, a badge opens a sub-agent map with cards, a stop button, and read-only transcripts, while two dialogs allow hooks and permission rules to be managed in user, project, and local settings.

🔗 Version 2.1.269 release notes

Antigravity: Four Versions in One Week and a Teamwork Catch-Up

Google released two versions of its command-line tool and a new version of its application in rapid succession, not counting two earlier versions never covered here. The changelog is worth reading as a whole, because the week’s releases tell the same story: the agent is leaving the interactive terminal to become a service.

🔗 Antigravity changelog

Antigravity CLI 1.2.0: The CLI Becomes a Remote Control-Managed Background Daemon

September 10 — Version 1.2.0 of the Antigravity CLI is the first minor-version upgrade since July. Three subcommands, remote-control start, status, and stop, register the command-line tool with the system’s service manager as a background daemon that survives disconnections and restarts, with one option for the instance name and another to restrict the service to the active login session. Until now, an open terminal had to be left running. Half-page scrolling has been extended to every view with two new default shortcuts. Of the eight fixes, the most useful for understanding unexpected behavior is this: a prompt or response blocked by content-safety filters now displays the explicit stop reason, where users previously saw a generic error or an empty turn. MCP servers embedded in global plugins now initialize correctly at startup.

Antigravity CLI 1.1.28: Expanded Error Retries, Faster Headless Mode, and Approval Required for URL Reading

September 9 — The previous day, version 1.1.28 focused nine improvements on resilience and headless mode, the mode invoked from a script. Transient model API errors are retried with extended exponential backoff, startup no longer triggers a network request to retrieve the user’s identity, and up to 200 milliseconds of idle delay has been removed from each turn. Two behavioral changes deserve the attention of anyone automating the tool.

Behavioral change	Before version 1.1.28	Since version 1.1.28
Timeout expiration in script mode	Timeout failure	Partial output returned, success code, warning
Agent reading an external URL	No prompt	Approval requested by default, unless access was preapproved

A script that relied on implicit web access must therefore grant this permission explicitly. Approval prompts now name the exact action and add a line explaining the reason when the request comes from a hook or a file belonging to another project.

Antigravity CLI 1.1.26 and 1.1.27 Catch-Up: One-Off Prompt on Another Model and Sub-Agent Dependencies in Front Matter

September 4 and 5 — Versions 1.1.26 and 1.1.27 close the gap and introduce the most concrete new feature of the batch: the model-selection command now accepts a prompt, executed once on another model before the session returns to the original model. This allows a second opinion from a more powerful or more economical model without changing the default setting. The same version adds an agent list to the Markdown front matter of custom agents, allowing them to declare the sub-agents they depend on, along with two fixes that matter for automation: an MCP call containing an argument not declared by the server’s schema is rejected and corrected instead of being silently removed, and a headless run names rejected actions in its JSON output instead of ignoring them without a word.

Antigravity 2.13.0: Documents Section, Virtualized Viewer for SQL and JSONL, and Citation Shortcuts

September 9 — Antigravity 2.13.0 brings 16 improvements and 16 fixes. External files added to a conversation—Google Drive links, PDFs, and Office documents—are grouped in a Documents section above Artifacts, instead of being mixed in with the agent’s outputs. Draft files that the agent writes for itself go into a separate section. Code and data artifacts such as SQL and JSONL files open in a virtualized viewer with syntax highlighting and line numbers, which remains responsive with large files and supports inline comments. A dismissed side question collapses into a button instead of being deleted, interactive prompts gain a cancel button, and selected text can be cited in the chat with a keyboard shortcut. Two fixes improve permission transparency: a rejected step remains visible with the Rejected label instead of disappearing, and the agent no longer asks again for permission to read artifacts from other projects when access outside the project has already been granted.

🔗 @antigravity tips thread on X

Teamwork, Catching Up on August 27

A post published on August 27, never covered here and still at the top of the developer section of the Gemini updates page, deserves a catch-up. Teamwork is Antigravity’s multi-agent orchestration framework, in which agents propose, critique, and refine one another’s work over hours or days, available in preview on all paid plans. Five patterns are included, selected automatically based on the prompt, ranging from iterative coding and document review to long-form proofs. With the long-form proof pattern, Google reports solving seven open problems, including the Knuth cycle conjecture, for which proofs of more than 40 and more than 70 pages were produced, with the 40-page proof formally verified in Lean; the other results were confirmed by human experts, and five papers have been posted on arXiv.

Reported metric	Value
TCSBench, Gemini 3.7 Flash and 3.1 Pro in long-form proof	71 percent
TCSBench, Gemini 3.6 Flash and 3.1 Pro, original paper	67.7 percent
RISC-V simulator, cycle alignment error	0.71 percent
Problems reproduced with Gemini 3.7 Flash	3 out of 7

Outside mathematics, Teamwork built from scratch a cycle-accurate out-of-order RISC-V processor simulator that boots the xv6 system to the shell and runs more than one hundred standard benchmarks, validated against hardware execution. Two contributions were merged upstream into open-source projects: a vectorized fast path in Eigen and a concurrent hash-table variant with twice the insertion throughput at 64 threads.

🔗 Teamwork, when AI becomes a research partner

GitHub Copilot Resolves Its Own Comments and Adds Jira to Its App

Code Review Moves to an Ensemble of Agents

September 11 — GitHub is updating Copilot code review on two fronts. On the experience side, when a later commit addresses a Copilot comment, the review resolves that comment automatically, so the list of open comments contains only items still awaiting a response; and when a code suggestion is applied, Copilot writes a commit message tailored to the change instead of using the prefilled message. On the analysis side, the review agent now has access to the full set of shell tools in the Copilot SDK, run behind the agent firewall: it can launch a build, run tests, execute a targeted script, or query accessible APIs to verify the code it is reviewing. GitHub reports more positive feedback, more high-severity findings, and fewer minor comments, without providing figures on this point.

The Lite effort level no longer relies on a single agent, but on an ensemble of agents that each contribute their perspective, merged into a single review.

Measured finding, ensemble Lite reviews	Announced change
Accepted comments, high severity	up 47 percent
Accepted comments, medium severity	up 31 percent
Accepted comments, low severity	up 11 percent
Cost of a review	approximately 8 percent less

Neither the number of agents in the ensemble nor the models used are specified. This is the third evolution of Copilot code review in two weeks.

🔗 GitHub Changelog

Jira in the App, HydraFusion in the Command Line, VS Code 1.137

September 10 — The weekly recap for the week of September 7, the week of Copilot Day, brings Jira integration to the Copilot app: tickets are brought into a shared canvas, users choose what moves forward, and Copilot carries the ticket context into investigation, implementation, and pull request preparation. In Copilot CLI, Project HydraFusion can now be selected like any other model, and chooses a workflow for each task across local, cloud, and composite models, balancing performance, cost, and latency.

VS Code 1.137, released on September 9, brings three agent features. Automations, in public preview, schedule recurring agent tasks hourly, daily, or weekly, using provided templates such as issue triage or bug hunting. Experimental voice mode lets users speak to an agent while it works, interrupt it, or redirect it. Finally, a link to an issue or pull request opens directly in the Agents window, even without an open repository. The release notes also add an agent host based on a dedicated protocol and powered by the Copilot SDK, aligning the behavior of the VS Code agent with that of the command line and the app.

🔗 Copilot weekly recap

Habitat, OpenAI’s Online Storage and Its Rust Rewrite by Two Engineers

September 11 — OpenAI has published the first part of an engineering post about Habitat, the online storage platform behind ChatGPT, the API, and Codex. The figures convey the scale: more than 70 million requests per second, more than one billion people served each week, nearly 40 regions, and more than 500 petabytes of data. Habitat began in mid-2024 as a small Python library embedded in ChatGPT’s main server, connected to a managed database, with a simple idea: product engineers should not have to think about schemas, routing, authorization, or connection pools.

By mid-2025, the client-side library model had reached its limits. Every protocol change required coordinating deployments across dozens of services; a regional routing deployment took days, then a service reverting to a buggy client caused the very outage the operation was meant to prevent. Habitat became a standalone service, and OpenAI chose to remain with Python while knowingly taking on technical debt, betting that its own coding models would make a future migration feasible.

Most of the post describes the hunt for tail latency at this scale: asyncio scheduling delays, which could reach hundreds of milliseconds, addressed by limiting concurrent requests per process; parsing configurations refreshed every minute without random jitter, which froze all workers at once; and the last-in, first-out reuse of connections by an HTTP library, which concentrated traffic on already slow processes, a metastable failure corrected first by reversing the order and then by delegating load balancing to a service mesh. The API itself is intentionally limited, an object-and-edge model without unbounded queries or joins, and this constrained scope is what made it possible to push Python so far.

Measured metric	Announced value
Requests per second today	More than 70 million
People served each week	More than one billion
Data served	More than 500 petabytes
Peak of the Python service	More than 20 million requests per second
Rust rewrite	Two engineers, Codex, and GPT-5.5
Share of traffic served by Rust	95 percent of production requests
CPU and memory efficiency improvement	6 times and 15 times

In the second quarter of 2026, two engineers rewrote the entire service in Rust with Codex and GPT-5.5. The Rust service handles 95 percent of production requests, using six times less CPU and fifteen times less memory; Python will be retired in the coming weeks. The second part will cover the storage layer.

🔗 Scaling storage to one billion users

OpenAI Asks Codex Users to Streamline Skills, AGENTS.md, and Prompts

September 11 — OpenAI’s developer blog has published a cleanup guide for Codex users moving to GPT-6 Astra. The starting observation: a year’s worth of accumulated instructions intended to guide earlier models becomes a burden for a more capable model. For skills, the mechanism is concrete: each skill loads a name and description into the context, and when there are too many, Codex shortens those descriptions, so the model sees less of each and makes poorer choices.

Instruction examined	Recommendation for GPT-6 Astra
Skill description	Short, precise trigger, not an entire domain
Structure of a multi-workflow skill	Root document reduced to a router pointing to docs and scripts
Required reading in AGENTS.md	One document per change type, not a stack to read for every edit
Testing instructions	Unnecessary; the model runs tests on its own
Task completion	Define what done means, pre-authorize safe workflows
Inherited prohibitions	Relax them, otherwise the model may stop prematurely

The most interesting point concerns the model’s behavior. OpenAI presents GPT-6 Astra as more cautious than its predecessor about the scope of a task, and likely to return for review after an initial implementation. The recommended response is to define explicitly what done means and grant permission in advance for workflows known to be safe, such as a local test suite with disposable fixtures. Conversely, very rigid guardrails written to restrain older models may now cause it to stop too soon. The post also notes that repository skills are read by other contributors’ agents, which sometimes run on different models: an instruction useful for those agents may overconstrain Astra. It concludes with a practical suggestion: ask Astra to audit the project’s instructions itself. The skill-creation skill has been updated accordingly.

🔗 Rethinking skills and prompts for GPT-6 Astra

ChatGPT Sites Surpasses 5 Million Sites in Three Months

September 11 — The official ChatGPT account has shared an update on ChatGPT Sites, the feature launched three months earlier for building and hosting complete web applications from a conversation: more than 5 million sites have been created since then. The post mainly recaps five developments that went largely unnoticed.

Two of them involve collaborative work. The first lets users invite teammates to edit, save, and publish a shared site; the second lets them grant specific people access to a site without making it public. The other three concern the site’s lifecycle: the time from prompt to deployment is reportedly half as long, ChatGPT can inspect the site’s database on request, with editors also having access to it, and a custom domain can be connected to the site. The developer account amplified the announcement, a sign that the feature also targets rapid prototypes and not only consumer-facing pages.

🔗 ChatGPT Sites update on X

Together AI Expands Its Fine-Tuning to 17 Open Models and Adds Adapters to Experts

September 11 — Together AI is expanding its fine-tuning service across the entire experiment lifecycle. Seventeen open-weight models are joining the catalog, including GLM 5.3 and its two previous versions, DeepSeek-V4-Flash, Kimi K2.7-Code and K2.6, the Qwen family from 0.8 to 35 billion parameters, and Gemma 4. The company cites a score of 88.2 for GLM-5.3 on Terminal-Bench 2.1, less than one point behind the best proprietary models, according to Together AI.

Experiment tracking is the second new feature: each job records loss, gradient norm, and learning rate at every step, with charts updated during execution, multiple jobs overlaid on the same graph, and raw series exposed through the API. Early stopping halts training when validation loss plateaus, retains the best checkpoint rather than the last one, and refunds unused steps.

The most technical feature is Expert LoRA. In a Mixture-of-Experts model, more than 90 percent of the parameters reside in the expert layers, which the conventional adapter leaves frozen by attaching only to attention.

Test on 200 fabricated facts	Adapters including experts	Attention-only adapters
Recall of new facts	up to 89 percent	15 percent
MMLU-Pro	75.3 percent	71.5 percent

The proposed explanation is that with attention-only adapters, a growing share of the routed experts falls into disuse during fine-tuning. Data processing also comes out of the black box, with a preview of tokenized rows, per-example weights, and complete server-side file validation as soon as the upload finishes. Training prices are falling by 30 to 70 percent depending on the model.

🔗 Together AI announcement on X

Community Contributions, One Sandbox per Attempt, and One Hundred Zebra Puzzles

On the same day, the Hugging Face community blog published three pieces of work that deserve more than a brief mention, and five others listed below.

How Thirteen Labs Run RL for Their Agents

September 11 — Sergio Paniego reviews fifteen reports from thirteen labs published between October 2025 and September 2026, retaining only what each says it trains, not what it evaluates. The central finding: the environment is no longer an in-memory simulator, but a complete machine with a file system, shell, and processes, launched for one attempt and then destroyed. Liquid AI does this for a 2.6-billion-parameter model, Cursor speaks of hundreds of thousands of concurrent environments to train its model, Microsoft provisions a fresh container for each task, and Kimi K3 goes further with resumable micro virtual machines for million-token trajectories.

Stack layer	What the labs maintain	Cited public equivalents
Tasks and verifiers	More than 10,000 code environments at GLM-5	Environments Hub, verifiers, Harbor
Action contract, harness	Kimi instantiates five white-box harnesses	OpenEnv, SkyRL, BrowserGym, TextArena
Sandbox	Hundreds of thousands of virtual machines per cluster	Modal, E2B, AgentENV, Hugging Face Sandboxes
Trainer	slime at Zhipu, Forge at MiniMax, RLVR at NVIDIA	TRL, Miles v0.1

One notable trend is that the harness is itself becoming the environment, either rebuilt as a white box or left intact and observed as a black box. Transparency varies widely: Ai2 documents 17.2 million verified code samples for OLMo 3, while OpenAI, Anthropic, and Google publish almost nothing, with the GPT-6 Astra system card consisting of a single sentence. The author cites a cost of more than ten million dollars for a single environment at major labs. The post concludes the Training Agents series.

🔗 One sandbox per rollout

One Hundred Zebra Puzzles Awaken Mathematical Reasoning

September 11 — A community article by tamewild reports that a few minutes of fine-tuning on 100 to 500 logic deduction puzzles, without any mathematical data, is enough to dramatically improve small base models on mathematics benchmarks.

Trained base model	MATH-500	AIME 2025	Compared official reference
Qwen 3 4B, 100 puzzles in 6 min 23	84.60 percent	21.67 percent	Post-trained version: 84.80 and 19.10
Granite 4.1 3B, 500 puzzles in 23 min	77.73 percent	19.44 percent	Instruct version: 66.60 and 6.67
Qwen 3.5 9B, 500 puzzles in 40 min	96.60 percent	60.67 percent	Post-trained version: 97.40 and 60.56

Structural effects are also measured: on the largest of the three models, the median response length falls below that of the official model, and the repetition-loop rate under greedy decoding drops from 6.06 to 0.67 percent. The author remains cautious, given exploratory runs with a single seed, and notes that his own ablations show a conventional adapter also reaches nearly 80 percent on MATH-500: the generalization comes primarily from the logic data. Code, notebooks, three models, and two datasets have been published.

🔗 Eliciting reasoning with 100-500 zebra puzzles

A Speech Pipeline for a Language Without a Dataset

September 10 — Osmanov recounts building a complete speech pipeline for Crimean Tatar, an endangered language with neither speech recognition nor speech synthesis, and shares a transferable conclusion: training was a rounding error. The recognition adapter took 90 minutes on a laptop GPU and reduced the word error rate from 34.6 to 20.1 percent, then to 17.0 with beam search that did not alter any weights. Almost the entire schedule went into building a nonexistent corpus and verifying that the evaluation was not misleading.

Two choices are worth remembering. The base model was selected according to phonetic priors rather than linguistic proximity: Crimean Tatar has a uvular /q/ that is absent from Turkish, and base models trained under a Turkish identifier rendered it as /k/, with fine-tuning failing to correct it. And with no recognition system available to bootstrap a corpus, the author reversed the problem by using audiobooks whose text was known, recovering 336 usable minutes where a drifting alignment produced only 110. The most useful negative result is a metric plateau: increasing the synthesis corpus from 5.9 to 15.3 hours did not change the character error rate, even though blind listening tests consistently preferred the newest voice. Finally, he documents a classic leakage issue: 96.9 percent of the test-book clips were duplicated in the training data, detected through text n-grams rather than filenames.

🔗 Speech tech for a zero-dataset language

Replit Launches Routines, Recurring Work That Calls the Agent Only When Needed

September 11 — Replit introduced Routines, a feature that runs recurring work on an hourly, daily, or weekly schedule. The announcement is interesting less for the scheduling, which is commonplace, than for how the company addresses cost. The starting observation is stated plainly: agents can now automate most repetitive tasks, but running them continuously consumes countless tokens. The solution is to keep the agent out of the center of the loop. Each run begins with deterministic code, and the agent is invoked only when reasoning is genuinely required.

This architecture runs counter to the dominant trend of entrusting an entire cycle to a model. Here, the model once again becomes a resource called only when needed, framed by ordinary code whose behavior and cost are predictable. For a scheduled task repeated hundreds of times, the difference in the bill is not marginal. The announcement was not accompanied by a blog post.

🔗 Replit announcement on X

Warp Integrates Grok Build as a First-Class Agent

September 11 — Warp announced integrated support for Grok Build CLI, SpaceX AI’s command-line agent, and the Grok account promptly shared the integration. The feature had already shipped in the terminal’s September 9 release, where the changelog describes it as first-class support: Warp detects Grok Build sessions, gives them dedicated visual treatment in the footer, and enables enhanced input mode for them.

In practical terms, Grok Build users inherit the same tools as the terminal’s native agents. Enhanced input accepts long pasted prompts and multiple cursors, which is a significant improvement for anyone writing multi-paragraph instructions. A command shares the current agent session with another device, while the file explorer and code review panels remain accessible during the session. An existing Grok subscription provides access, with no specific pricing or limits announced.

The addition expands an already substantial list of third-party agents hosted in Warp’s terminal, alongside Claude Code, Codex, Droid, and Antigravity, and extends work begun earlier in the summer around the xAI ecosystem, including a command added in August for signing in with an X Premium or SuperGrok account. Warp’s rationale remains the same as when it launched its agent: rather than locking users into an in-house agent, it aims to make the terminal the place where all agents run with the same quality of integration. The rest of the release fixes two annoyances: prompts that have been entered but not sent are no longer erased when switching models, and MCP tools declared in a global file are available from the agent’s first response.

🔗 Grok announcement on X · 🔗 Warp announcement on X

Vibe CLI 2.25.3, the Fork Command and Private Session Logs

September 11 — Mistral released version 2.25.3 of Vibe CLI, its third release in three days. The visible new feature is the /branch command: it forks the current conversation into a new resumable session while leaving the original session intact. The copy can then be resumed in another terminal, making it possible to explore an alternative path from the same context without sacrificing the main thread. At-sign file mentions now use Git-aware discovery and accept files or folders pasted directly into the prompt.

There are three fixes. Saved conversations remain readable and restore their worktrees when work resumes. New session logs are no longer readable by other users on POSIX systems, a file-permissions fix that follows version 2.25.1, which removed an unauthenticated debugging listener and ensured that no failure could result in automatic approval. Finally, instructions from the AGENTS.md file are now loaded into the system prompt under the experimental unified harness. The release comes with fourteen binary archives; no notes mention changes to models or pricing.

🔗 Vibe CLI 2.25.3 release notes

Synthesia Turns Its Compliance Agent into Shared Infrastructure

September 10 — Nicolás Barberis, Head of Trust Operations at Synthesia, published a follow-up to his June post about the agent that collects compliance evidence. The question that guided the redesign came from readers: as soon as an agent collects audit evidence, the collection process falls within the audit’s scope, and the collector itself must be trustworthy. The answer consists of four architectural choices, all broadly applicable.

First, separate the mechanics from the methodology. The code lives in an internal repository and changes through pull requests, with a code owners file requiring human review; the procedures for each control category live in a documentation space, written and approved by the control owners. The initial script with hard-coded URLs became a shared skill that a colleague can install with a single command. Next, constrain the browser: the agent never touches the everyday browser, copies the session into a disposable profile, operates with read-only roles where available, and stops at an authentication wall rather than escalating its privileges. Provenance is built in by design, with every capture created alongside its source URL, timestamp, operator, and the cryptographic hash of the exact bytes. Finally, human accountability: the agent saves drafts and never submits them.

Measured result	Value
Evidence review meetings with auditor	60 percent fewer
New framework processed	about 500 controls
Typical timeline for such a framework	4 to 6 months
Timeline achieved	a few weeks

The knowledge base grows on its own through append-only updates: after each run, the agent records corrected URLs and dated blockers, such as a browser automation interface breaking with a recent Chrome version, worked around by connecting directly to the debugging protocol. Synthesia says the tool is evolving into an AI-assisted governance platform and is considering open-sourcing its core components.

🔗 Who audits the collector

HeyGen Breaks Down the 16-Second One-Take Furniture Unboxing

September 11 — HeyGen published the making-of for a 16-second video in which a man places a cardboard box in the center of an empty concrete room, walks away, and the box explodes to release a complete living room that settles into place. No 3D, no compositing, nothing in post-production: two still images, one avatar, and one prompt. The team verified the absence of cuts across all 390 frames, with the largest change between two consecutive frames corresponding to the explosion itself.

The method relies on the two reference images. The first shows the empty room in a wide, fixed shot, with the center of the floor clear. The second is the same image edited to add the furniture, rather than a new rendering of a similar room: same camera position, same lens, same lighting, same shadow on the concrete. This is the rule that makes the effect work, since the model then has to invent only the middle.

Video parameter	Value
Duration requested in the prompt	15 seconds
Delivered duration	16.27 seconds
Resolution and frame rate	1920x1080, 23.976 frames per second
Frames without a cut	390
Inputs	2 still images, 1 avatar, 1 prompt

The prompt is written as a timed shot list rather than a description, with a deliberate pause before the explosion. Six elements underpin it: timestamps, that pause, references named by role, furniture listed item by item, identity defined through negatives, and permission to exaggerate, without which the model respects the actual volume of a cardboard box. The field notes are useful: the model delivered 16.27 seconds instead of 15, an explosion faster than written, and a lingering shot of the finished room that no one had requested, which the team considers the best moment in the edit. Hence the advice to write timings to establish pacing and order, then edit to the delivered rhythm. The sound changed between two passes, with the nearly silent version giving way to a continuous sound bed, because an autoplaying silent video can seem as though its audio is broken.

🔗 How we made The Furniture Unboxing

Nemotron 3 Embed 8B Takes First Place on the Q2D-Web Benchmark

September 10 — NVIDIA announced that Nemotron 3 Embed 8B, its 8-billion-parameter embedding model, ranks first on Q2D-Web for combined nDCG@10 score. Q2D-Web is the benchmark published the previous day by Perplexity to evaluate document retrieval in agent-driven retrieval-augmented generation systems: it covers 190 million web documents and nearly 70,000 agent-reformulated queries across 10 languages.

The result matters for two reasons. The benchmark reproduces the real-world conditions of an agent reformulating its queries before searching an index, something conventional embedding evaluations do not measure. And an open model of this size topping a multilingual leaderboard becomes a credible candidate for self-hosted pipelines competing with proprietary embeddings. NVIDIA does not publish the numerical score; the full leaderboard is available from Perplexity.

🔗 NVIDIA announcement on X

Marketing ops as code, events driven from a GitHub issue

September 11 — Tomoko Tanaka, GitHub’s regional marketing lead for Japan and Korea and a former engineer, describes how she automated the entire lifecycle of her events without writing the code herself: she documented her procedures and handed them to Copilot, with the automation growing through conversation.

Three primitives underpin the system. Issue forms capture an event’s structured fields, with one form per type. Labels act as switches, with each label triggering a workflow. GitHub Actions does the work: reading fields, duplicating a past event page through the platform API, generating tracking links for each channel, producing the invitation email committed to the repository, opening request issues with the relevant teams, and populating project boards. A scheduled workflow filters registrants every morning. The only prerequisite, she writes, is scriptable access to the tools, an API, or even a simple command-line client.

Planning begins with a conversation with Copilot, guided by an AGENTS.md file at the repository root that defines naming rules, fiscal-quarter mappings, and the time zone for each region. The conversation first took place in the terminal, then in the app, lowering the prerequisite from “comfortable with a shell” to “can type.” Post-event work takes just two commands, which are agent skills written in prose, added via pull request, and reviewed through an owners file before merging: marketing gets an approval process without building anything. A simulation switch, stored as a repository variable, runs every workflow in dry-run mode. The admitted failure alone makes this worth reading: the morning filtering workflow once failed silently for five days before someone noticed stale lists, hence the advice to give every scheduled task a way to complain loudly.

🔗 Marketing ops as code

Boris Cherny responds on throwaway code and production code

September 11 — Boris Cherny, who leads Claude Code at Anthropic, publishes the response he sent to a developer whose email was titled “What to do about slop?”. The author, who has spent twelve years at the same company, describes two camps that have emerged on his team with agentic development. In the first, code remains similar to what it was, only produced faster: perhaps not all of it is reviewed, but it must remain reviewable, the person submitting it must be able to explain it, and it must be as easy to maintain as before. In the second, code is a black box whose output alone is checked.

The response comes down to two rules. Prototypes and throwaway code can be treated as complete black boxes if they will be discarded and the blast radius of a failure is small. Production code written by Claude, however, must be held to a higher standard than if it had been written by a human. At Anthropic, that means extensive lint rules, many tests, end-to-end tests driven by Claude, fuzzers that run every day, and automated code and security reviews. Without those safeguards, he warns, the result is a mess that is difficult to maintain.

Next comes a list of remedies, in order, when the generated code does not meet the standard: switch to the latest frontier model, increase reasoning effort, and invest in CLAUDE.md and skills to teach Claude succinctly how to work within the codebase. If none of that helps, guide it more closely, have it pay down the accumulated debt, or wait for the next model. The replies settled on the most repeated formulation: the review standard should follow the blast radius, not the author of the code; a throwaway script can be shipped, but anything involving money or credentials should be read line by line. Boris Cherny replied, “Exactly.”

🔗 Boris Cherny’s thread on X

Briefs

Amp adds a button that reorganizes a thread’s commits — one action transforms an agent’s intermediate commits, successive fixes, and reversals into a reviewable series. Three cited uses: splitting a large diff into logical pieces, cleaning up before merging, or grouping small related commits. The final contents of the files remain strictly identical. 🔗 source
Amp releases episode four of Raising an Agent season 2 — Quinn Slack and Thorsten Ball begin with the question of what computers are now for, examining what agents do beyond producing code, with a retrospective on recent outages. 🔗 source
v0 makes team conversations visible by default — new conversations in a shared workspace become visible to the team, with three levels configurable by the owner (private, view, edit). Existing conversations retain their visibility. A shift toward greater openness is never neutral in a tool where people readily paste snippets of data while prototyping. 🔗 source
Audiyo fits Stable Audio Open onto an 8 GB GPU — a Python library and command-line tool that reduce peak video memory from 13.8 to 5.86 GB, or 57.5 percent less, with four presets measured on a Tesla T4. The team first validated its work on a CPU using a surrogate model with 5.38 million parameters, catching four bugs before touching a GPU. 🔗 source
Consent All the Way Down, a consent architecture for a council of small open models — an essay authored by a Claude instance on a council of eighteen models with 7 billion parameters or fewer, which has been running continuously since May on three consumer machines. Each source is a channel whose depth the model chooses, and nothing writes to its state except the model itself. The most candid part is the audit of the authors themselves: the mailbox had been broken since June, with 213 letters piled up. 🔗 source
There is no arms race; there is a browser war — an opinion essay arguing that the language model is becoming a commodity, secret weights or not, and that the leaders’ advantage is measured in weeks. The author cites Fable 5’s 18-day suspension this summer, during which the rest of the industry kept moving. His thesis: value will shift toward the context accumulated around the user, just as bookmarks and extensions kept users on Chrome. 🔗 source
From barge-in to floor control, handling voice interruptions under uncertainty — Eric Mey replaces destructive interruption with a turn-taking controller using reversible actions, with a separate path for ambiguous fragments and a precedence rule between emergency stops and echo suppression. The testing lesson is worth remembering: a green suite concealed a reversible pause that had been registered but never called, because a green gate only authorizes what it has examined. 🔗 source
Aiden separates the real-time voice model from the agent that performs tasks — a full-duplex voice model maintains the conversation while a stronger, visually grounded model performs device-control tasks in the background, with the two coordinated through an asynchronous queue. Four details matter: distinguishing completed from successful, aggregating notifications over 500 milliseconds, passing state through appended messages to preserve the cache, and strictly serial execution. 🔗 source
GPT-Live-1 handles Yelp reservation calls — the day after the model arrived in the API, OpenAI demonstrates an early customer in a scenario where the script never holds: the caller interrupts, adds a constraint, or changes their mind mid-sentence, and the model keeps listening while it speaks. Demonstration video, with no volumes or quantified results. 🔗 source
Verifying the agent’s work with the diff, terminal, and browser panels — a new episode in Kayla Cinnamon’s beginner series on the Copilot app, focused on the three integrated panels and a tool that lets users select a page element to adjust it with the agent. The post summarizes the loop as three questions to ask before accepting code: what changed, does it run, and does it actually work? 🔗 source
A repository’s pull requests page is redesigned — public preview for everyone: filter input assistance, search with Boolean operators and nested queries, a collapsible sidebar, compact mode, and more context per row. Known limitations at launch: milestones are not displayed, bulk updates are unavailable, and custom views cannot be saved. 🔗 source
GPT-5.6 Sol at a 30 percent discount in Copilot — for Pro+ and Max subscribers, through September 13 at 12:00 a.m. UTC. The message does not say what premium-request multiplier the discount corresponds to. A weekend promotion, just after Copilot Day, for the model that appeared in several cost comparisons on the same day. 🔗 source
GitHub Copilot Day contest, three $100 credits — build something with the Copilot app or its command-line client and share it publicly with the specified hashtags by September 13 at 11:59 p.m. Pacific Time. Three winners, each receiving $100 in GitHub Shop credit; entry is free and limited to adults. 🔗 source
Runway can be used in ChatGPT with Astra — a demonstration of a complete workflow driven from the conversation: a style image in Runway, animation in Blender, and final rendering with Seedance 2.5. The technical entry point remains the Runway Dev MCP server unveiled on September 2. The appeal lies in chaining heterogeneous tools under the control of a single agent. 🔗 source
Runway publishes the VOIDZ case study — an anonymous mixed-reality artist active since 2018 moves from 10-to-15-second shots to a 95-second film with 15 surreal interventions grafted onto a real grocery run. Most effects extend an existing shot, using a few seconds of documentary footage as a starting point. Production is claimed to be 10 times faster; the artist estimates the same work would take six months to a year using traditional 3D. 🔗 source
Runway adds speakers to its AI Summit — a new wave of speakers for the San Francisco event, prominently featuring Wayve’s director of research, confirming the program’s expansion into autonomous vehicles that began in late August. 🔗 source
NVIDIA streams From Video to Voice, 33 minutes on TensorRT Model Connect — a replay focused on the tool unveiled in late August, which deploys an open model from checkpoint to inference in two commands, spanning video models to voice models. Training content rather than an announcement. 🔗 source
Suno extends its credit-free v6 period by two days — the 48 hours announced the previous day become four days, accompanied by a thread of tips recommending starting from a mood rather than a genre in simple mode. The previous day, a transition guide targeted users returning to older models for their variation and texture, a sign that migration is not straightforward for the entire user base. 🔗 source
Synthesia enables avatar creation from a prompt — realistic presenters, brand mascots, or stylized characters, described with a text prompt or configured through a control panel as an alternative to the catalog. Announced in a single tweet without a link, the day after the release of a new avatar model; neither the eligible plans nor the model used are specified. 🔗 source
The GPT-6 Astra Challenge opens for submissions — build with Astra and launch the project on Product Hunt on September 18. The five top launches each receive $10,000 in API credits and one year of ChatGPT Pro for up to two team members. The third community initiative centered on Astra in one week. 🔗 source
OpenAI project API keys can expire — an expiration date can be set at creation, and administrators can impose a maximum lifetime at the organization or project level, requiring every new key to expire within that period. A natural complement to key rotation, worth enabling for organizations that leave keys lying around in scripts. 🔗 source

What It Means

The clearest thread of the day is architectural: the single-model approach is giving way to composition. Cursor places a coordinator that writes no code above thousands of sub-agents, Cognition pairs two models with distinct roles and separate contexts, Sakana routes each task to the lightest model capable of solving it, GitHub replaces a single reviewer with a set of agents whose findings it merges, and Google has agents propose, critique, and refine one another for days. Five companies, five implementations, one shared conviction: gains no longer come from a larger model, but from how multiple models divide the work. The technical detail shared by Cognition and Aiden is revealing: both emphasize preserving the prompt cache, meaning that the true cost of an architecture lies in what it avoids retransmitting.

The second thread concerns how these capabilities are sold. Runway licenses closed weights annually, including checkpoints, the training script, and researchers deployed on the customer’s premises, explicitly positioning this offering against open weights. OpenAI is taking a specialized model out of research preview with public pricing and a billing start date. ElevenLabs grants ownership of tracks on every plan, including the free tier, and ties permissions to the track rather than the subscription. Together is cutting its training prices by 30 to 70 percent. Cognition goes so far as to propose changing the unit of measurement and evaluating a model-harness pair by cost per task rather than cost per token. These moves all point in the same direction: the question posed to the customer is no longer which model, but under what legal arrangement and with which billing unit.

On tooling, the day marks a shift from the declarative to the measured. Anthropic is shipping a command that reruns every test case without the plugin to demonstrate, with figures to back it up, that the tool is actually useful—and the typical first finding is zero difference. OpenAI is asking its users to remove accumulated instructions because they now hinder a more capable model. Replit and VS Code are releasing recurring-task scheduling almost simultaneously, with Replit stating an explicit principle: start with deterministic code and invoke the agent only when reasoning is necessary. Boris Cherny provides the rule of discipline the entire field has been missing, making the required rigor depend on the blast radius rather than on who wrote the code. After two years of accumulating contexts, skills, and instruction files, the industry is beginning to measure their cost.

Then there is infrastructure, where the numbers tell a less glamorous but more instructive story. Two engineers used Codex to rewrite in Rust the storage service handling more than 70 million requests per second, reducing CPU usage sixfold; the Python debt knowingly incurred in mid-2025 was paid off in one quarter. At the same time, Hugging Face’s survey shows that reinforcement training for agents now consumes an entire machine per attempt, with environment budgets exceeding ten million dollars and transparency inversely proportional to laboratory size. And a community essay argues that none of this constitutes a lasting lead, since the gap between the leaders is measured in weeks. The day’s facts do not settle the matter, but they offer an indication: differentiation is shifting toward accumulated context, the harness, and infrastructure—in other words, toward what cannot be distilled.