This post walks through the Agents CLI evaluation loop for systematically improving agent performance through continuous testing and grading. It demonstrates how to catch prompt regressions, evaluate model backend swaps using side-by-side trace comparisons, and automate evaluation passes. Developers will also learn how to integrate nightly scheduled runs with threshold-based alerting to track quality over time.

Google is giving coding agents like Anthropic’s Claude Code and OpenAI’s Codex deeper access to its Android development tools, including devices, performance profilers and production crash reports; now, agents can now investigate bugs, test changes, and verify their own fixes.

The push spans Android Studio and the terminal-based Android CLI, with Google opening both to third-party agents rather than steering developers toward Gemini. Matthew McCullough, vice president of product for Android, has emphasized giving developers the freedom to choose their own models and coding agents.

In a Wednesday post, Adarsh Fernando, senior product manager for Android developer tools, describes the goal as giving developers and their agents “the tools and knowledge to build high-quality Android apps faster.” The updates were announced Wednesday at Android Dev Summit.

Bring your own agent

The company’s Bring Your Own Agent feature now supports more than 40 coding agents that speak the open Agent Client Protocol, among them Anthropic’s Claude Agent, OpenAI’s Codex, and Google’s own Antigravity, and Google says the feature is now stable in Wednesday’s release of Android Studio Rabbit 2.

A developer can install several and switch between them without leaving the IDE, and connected agents inherit the IDE’s own read on a project — its structure, build configuration, symbols, and tools such as Compose Preview, the emulator, and Logcat — context they would otherwise have to rebuild through code searches and terminal guesswork.

Alongside it, a new Change Review feature scans an agent’s pending changes for common issues and can walk a developer through a large set of modifications before anything is applied, and Google is pushing the same reach beyond the IDE with official Android CLI plugins for Claude Code, and Codex that cover project creation, emulator management, UI inspection, and its Android documentation.

Compose previews from the terminal

Another announcement includes the new android preview command that lets coding agents render Jetpack Compose previews directly in the terminal without launching an IDE or emulator.

The company says agents using it completed UI tasks 77% faster while using up to three times fewer tokens, though it shared little about how it measured those results. The CLI also adds android device remote, giving agents access to physical devices in Google’s lab for testing.

agents using it completed UI tasks 77% faster while using up to three times fewer tokens, though it shared little about how it measured those results.

Finding memory leaks with Claude

Google is also giving agents more ways to investigate problems after an app is built, including performance issues, production crashes and memory leaks. In one demo, Claude Code worked with LeakCanary, an open source leak-detection library, to check critical user journeys for memory leaks using a single instruction from the developer.

Claude Code ran the journeys across multiple devices in parallel, analyzed heap dumps through the CLI’s LeakCanary integration, and traced the leaks back to the offending code. It then made the fixes and reran the tests to confirm they worked. Google says the tooling helped capable models complete these investigations nearly twice as fast while using up to 25% fewer tokens.

autonomous bug-finding can outrun autonomous bug-fixing — an Anthropic scanner flagged some 29,000 possible vulnerabilities in open-source code while only a few hundred were ever fixed.

The demo is very impressive, and it also runs against a record that counsels patience, since autonomous bug-finding can outrun autonomous bug-fixing — an Anthropic scanner flagged some 29,000 possible vulnerabilities in open-source code while only a few hundred were ever fixed.

A companion android signals command now pipes Android vitals and Firebase Crashlytics data into the same terminal workflow, which gives agents a direct line to production crashes, ANRs, and memory problems, but none of this retires the human in the loop, as developers who watched Claude Code land a Linux kernel fix only for reviewers to catch a race condition can attest.

A companion android signals command now pipes Android vitals and Firebase Crashlytics data into the same terminal workflow

Benchmarking agents with Android Bench

Google is also introducing Android Bench 2.0 to evaluate how models and agent harnesses perform on more complex Android development tasks. It tests whether completed apps actually run with assignments ranging from building an app from mockups to migrating an existing interface. Some tasks are modeled on work that would take an Android engineer several days, and the benchmark also measures completion time and cost.

The post Google just handed its rivals the keys to Android appeared first on The New Stack.

Math is beautiful – check it out on Codepen

At WeAreDevelopers, we love to code. We love the concept of creating something from nothing, finding a solution for a problem and create something people can get excited about.

That’s why we thought we’d give you a challenge to show what you can do with an HTML document containing some wisdom by Lao-Tzu about what several concepts become when love is missing.

We’ve used this to learn about some new(ish) things in CSS we hadn’t played with before and we encourage you to use this as an opportunity to try out something new.

There are no rules what you do with this and what tech you use.

• We will pick three winners in the next few weeks
• We will invite them to a special edition of Coffee With Developers to talk about their submissions. This means that of course you can use AI to create your submission, but we also want you to be able to explain what you’ve done and why it works.
• All winners get a free ticket to one of our events, either in Berlin, Bengaluru or San Jose .

You can submit your solution as a pull request here – simply create a folder with your name and code in the entries folder.

• Here are all the submissions so far – to start, Chris Heilmann added a text mover and a simple shuffle effect .

Show the world what adding some love can do.

GitHub has debuted GitHub Copilot Fusion, a new system that handles model selection and orchestration for coding tasks so developers don’t have to. 

Combining the advanced runtime model orchestration from Project HydraFusion with Copilot Auto Model Selection, Copilot Fusion can now handle both model selection and orchestration. GitHub says Fusion Max delivered comparable benchmark performance to Claude Code with Opus 5.5 Max at about half the average API cost and in about 40% less time per task.

Generally available now, GitHub Copilot Fusion is part of GitHub’s new vision to make GitHub “the most comprehensive software delivery system in the world,” with developers delegating model choices while retaining responsibility for the direction and outcome of the work.

GitHub announced the news on Wednesday at GitHub Universe in San Francisco, the company’s flagship developer event.

GitHub Copilot Fusion is the decider now 

For tasks involving reasoning, code generation, debugging, or tool use, GitHub says developers can delegate decisions about which models to use and how they work together. Its instructions: “choose Copilot Fusion and let Copilot intelligently route and orchestrate which models it uses for you.”

That sounds like a time-saver, since different tasks benefit from different models based on capabilities and cost. With Copilot Fusion working as the “model picker,” developers don’t have to weigh performance and price for every task.

More compelling is the idea that developers can use Copilot Fusion to strategically switch models mid-workflow, letting the system jump between models based on what best suits each step. 

After analyzing what the task requires and choosing a model, the system orchestrates the next steps based on what makes the most sense. That may be a single model doing everything, a “cascading” workflow where a quality check evaluates one model’s response and then decides to accept it or escalate it, or a “critique” workflow where one model reviews another’s work.

That could reduce the mental load for developers who may inadvertently choose inefficient models when their attention drifts.

As Hari Pokhrel, principal software engineer at AT&T, describes in a statement for GitHub: “Previously, developers would often choose a more powerful model for a complex task and forget to switch back for everyday activities.” 

So, what do developers get to decide for themselves?

Mostly, the effort level. 

While Copilot Fusion handles model selection and orchestration, developers choose the effort level: Fusion Standard for everyday coding; Fusion High for more challenging tasks and deeper reasoning; Fusion Max for the most demanding, complex work.

That’s if you’re free and comfortable letting GitHub’s systems take the lead. If you prefer, developers can implement other controls. 

Per GitHub, enterprise administrators can control which models Copilot Fusion can choose from, disabling certain models for Copilot Fusion without disabling them for the entire developer team. Administrators can also adjust the policy state for each model independently and set whether Copilot Fusion is or isn’t the default model for Copilot users.

The case for letting Copilot Fusion be your guide

According to GitHub and Pokhrel’s statement, offloading model selection and orchestration to the new fusion system is the smarter route for developers, letting you balance performance and cost without the friction of choosing between models.

GitHub says it has improved performance since launching Project HydraFusion as a research preview in September 2026. On the Artificial Analysis Coding Agent Index, GitHub reports that Copilot Fusion Max scored 60, within two points of Claude Code with Opus 5.5 Max. GitHub says Fusion Max delivered that result at about half the average API cost per task, using about half as many tokens and taking about 40% less time per task.

In the statement supplied to The New Stack by GitHub, Pokhrel credits Copilot Fusion Standard with improving token efficiency at AT&T, reducing unnecessary spending, and preserving capacity for higher-value work.

Model routing is becoming the default

Copilot Fusion is one piece of GitHub’s future vision, released alongside a slew of other products at the conference, including the GitHub Copilot app, Copilot Projects, and Copilot Automations.

By deferring model selection to its system, GitHub thinks developers will have more time and brainspace to focus on other work. 

It looks like everyone is moving that way. This month, Ramp described moving model selection into Open SWE, its open-source coding agent. In the summer, Replit did the same, making its “intelligent model routing” system the default across every account.

The post GitHub debuts Copilot Fusion, a new model selection & orchestration system that beats Claude Code for half the API cost appeared first on The New Stack.

GitHub is seeing unprecedented demand and is updating its core infrastructure to keep pace.

In August, GitHub said it was seeing 2.9 billion commits per month, up from 1.4 billion in April. At its GitHub Universe conference on Wednesday, the company announced that it is now seeing 7.4 billion commits per month. To put that into perspective, developers pushed 65 million monthly commits to the platform in 2024.

That kind of growth is a great problem to have, but the company’s outages have become something of a recurring theme. The reason is rapid usage growth, driven mostly by “agentic demand,” as the company puts it.

4 million more CPU cores

In August, GitHub CTO Vlad Fedorov announced that the platform had added 3 million CPU cores — mostly on Azure — to support this growth. Now, GitHub says it has added 4 million CPU cores, plus 160 petabytes of high-speed storage and more compute power for GitHub Actions so far this year

The company also added 50 Tb/s of network capacity to keep all of this data flowing.

A new GitHub architecture is coming

GitHub also used this announcement to reiterate its commitment to rearchitecting its platform to separate compute and storage. It first talked about this earlier this month. At that time, the company noted that its internal benchmarks show that this new architecture can deliver up to 35x higher write throughput, for example.

“Agents are changing the volume and shape of software development. Adding capacity matters, but capacity alone won’t get us there. We’ve also had to change the architecture,” Jay Parikh, the EVP for Core AI at Microsoft, writes in the announcement.

Separating compute and storage isn’t exactly radical in 2026, but it shows GitHub was trying to scale on a legacy foundation. Moving to Azure and its services was essentially the only option, especially as the company’s own data center was out of capacity.

The post GitHub saw 7.4B commits in September, adding 4M CPU cores and 160 PB of storage to keep up appeared first on The New Stack.