Apple's Siri AI Can Be Swapped Out for Claude, ChatGPT, Code Shows

Code sleuth "pdfu" has uncovered iOS 27 and macOS Golden Gate private frameworks that show Apple has designed its new Siri architecture to work with third-party AI models at what appears to be a surprisingly deep level.

One mechanism called Model Delegation allows Claude to appear as a Siri extension in the same way as the existing built-in ChatGPT extension. In pdfu's video, shared on X, the macOS user brings up the "Search or Ask" bar and chooses Claude as the AI model via an "Ask..." contextual menu.

After enabling the Claude extension, the user asks Siri to "Ask Claude" to set a reminder in Apple's Reminders app. Claude then interprets the natural language reminder request and Siri subsequently creates the reminder. The implication is that if the request requires access to an Apple system feature, Claude hands the task back to Siri.

In another example, Claude can be seen in a Siri app conversation window receiving a request to create a CSV file – something Siri itself cannot handle – and successfully returning the result.

What's more intriguing is the second protocol demonstrated in the video that appears to go considerably further, and could really open up the AI landscape for Apple software requests.

An inference provider in "Model Manager Services" apparently allows Apple's own server-side Siri model to be completely replaced by another model, such as GPT-5.6. In this scenario, ChatGPT receives Apple's Siri planner prompt and tool definitions, which enables it to request system actions, receive the resulting personal data, and formulate an answer that Siri presents using its own interface and voice.

And here's an app extension replacing Siri AI's server model with GPT-5.6 Terra. It uses the Inference Providing protocol in Model Manager Services. GPT-5.6 receives Apple's native Siri planner prompt and tool definitions. It can make tool calls that perform system actions, and...

In the demonstration video, the user asks the ChatGPT model (within the Siri app) to find emails about a specific topic, summarize their contents and action points, then send a message to a person in the user's contacts via the Messages app. The response is then shown as logged in OpenAI's platform web interface.

The European Union's Digital Markets Act may have helped shape Apple's approach here, as it requires Apple to give third parties effective access to iOS hardware and software features available to Apple's own services, and the European Commission has specifically said this principle extends to Siri.

The "Ask..." implementation is currently limited to the ChatGPT extension in the macOS 27 Golden Gate Release Candidate (which is effectively the final version of the software set to be released later today), so Claude is not yet available. Meanwhile, Apple has not yet opened up the model delegation entitlement to third parties and it isn't front-facing to users, but it at least shows how extensively Apple has engineered Siri for future model interoperability.

iOS 27 marks the beginning of an iPhone divide: only Apple Intelligence-capable models will get Siri AI and other AI-powered features. The new Siri AI uses Google's Gemini models to answer questions. It can look through users' private data, but Apple says it doesn't store user data and that neither Apple nor Google can access it. This article provides a summary of the new capabilities Siri AI has as well as the new features available to all iPhones with iOS 27.

Apple's Siri AI Can Be Swapped Out for Claude, ChatGPT, Code Shows

Code sleuth "pdfu" has uncovered iOS 27 and macOS Golden Gate private frameworks that show Apple has designed its new Siri architecture to work with third-party AI models at what appears to be a surprisingly deep level.

One mechanism called Model Delegation allows Claude to appear as a Siri extension in the same way as the existing built-in ChatGPT extension. In pdfu's video, shared on X, the macOS user brings up the "Search or Ask" bar and chooses Claude as the AI model via an "Ask..." contextual menu.

After enabling the Claude extension, the user asks Siri to "Ask Claude" to set a reminder in Apple's Reminders app. Claude then interprets the natural language reminder request and Siri subsequently creates the reminder. The implication is that if the request requires access to an Apple system feature, Claude hands the task back to Siri.

In another example, Claude can be seen in a Siri app conversation window receiving a request to create a CSV file – something Siri itself cannot handle – and successfully returning the result.

What's more intriguing is the second protocol demonstrated in the video that appears to go considerably further, and could really open up the AI landscape for Apple software requests.

An inference provider in "Model Manager Services" apparently allows Apple's own server-side Siri model to be completely replaced by another model, such as GPT-5.6. In this scenario, ChatGPT receives Apple's Siri planner prompt and tool definitions, which enables it to request system actions, receive the resulting personal data, and formulate an answer that Siri presents using its own interface and voice.

And here's an app extension replacing Siri AI's server model with GPT-5.6 Terra. It uses the Inference Providing protocol in Model Manager Services. GPT-5.6 receives Apple's native Siri planner prompt and tool definitions. It can make tool calls that perform system actions, and...

In the demonstration video, the user asks the ChatGPT model (within the Siri app) to find emails about a specific topic, summarize their contents and action points, then send a message to a person in the user's contacts via the Messages app. The response is then shown as logged in OpenAI's platform web interface.

The European Union's Digital Markets Act may have helped shape Apple's approach here, as it requires Apple to give third parties effective access to iOS hardware and software features available to Apple's own services, and the European Commission has specifically said this principle extends to Siri.

The "Ask..." implementation is currently limited to the ChatGPT extension in the macOS 27 Golden Gate Release Candidate (which is effectively the final version of the software set to be released later today), so Claude is not yet available. Meanwhile, Apple has not yet opened up the model delegation entitlement to third parties and it isn't front-facing to users, but it at least shows how extensively Apple has engineered Siri for future model interoperability.

Generative media platform for developers.

The world's best generative image, video, and audio models, all in one place. Develop and fine-tune models with serverless GPUs and on-demand clusters.

Enterprise Scale

The world's largest generative media model gallery

Choose from 1,000+ production ready image, video, audio and 3D models. Build products using fal model apis. Scale custom AI models with fal serverless. Access 1000s of H100, H200 and B200 VMs with fal compute.

Explore all models

1000+ generative media models. Ready for production.

Explore a rich library of models for image, video, voice, and code generation. All accessible with a simple API. No fine-tuning or setup needed — just call and go.

Use it for:

• Building with state-of-the-art open models
• Personalize models for your own brand or persona
• Exclusive early access to new models

On-demand, serverless GPUs.

Run inference at lightning speed with fal's globally distributed serverless engine. No GPUs to configure, no cold starts, no autoscaler setup.

Use it for:

• Access to fal Inference Engine to accelerate your workloads
• Scale from zero to thousands of GPUs instantly
• All-in-one framework: run, deploy, productionize
• Monitor everything with best in class observability toolchain

Dedicated clusters for frontier research labs.

Spin up dedicated compute to fine-tune, train, or run custom models with guaranteed performance. Choose from the latest NVIDIA hardware across global regions.

Use it for:

• 1000s of Blackwell™ NVDIA chips
• Run large scale training workloads
• Proprietary distributed data-feeding engine
• Enterprise-grade reliability and scale

Why choose fal?

Fastest inference engine for diffusion models

fal Inference Engine™ is up to 10x faster. Scale from prototype to 100M+ daily inference calls — with 99.99% uptime and zero headaches.

On-demand GPUs, serverless deployments

Deploy private or fine-tuned models with one click — or bring your own weights. Customize endpoints securely with enterprise-ready infra.

Built for developers

Use our unified API and SDKs to call hundreds of open models or your own LoRAs in minutes. No MLOps, no setup — just plug in and generate.

H100s, H200s, B200s starting at $1.89

Pay only for what you use. Choose per-output pricing for Serverless, or hourly GPU pricing with Compute. Scale without lock-in or hidden fees.

Built for enterprise scale

fal powers AI features in some of the world's most demanding environments — from public companies to hypergrowth startups.

“fal's platform has been instrumental in accelerating our AI innovation journey. We love the flexibility of the platform and the extensive model offering.”

Morgan Gautier

Head of Generative AI Experiences at Canva

“I believe the future of image and video search is AI-driven. fal is our trusted infrastructure partner as we scale Perplexity's generative media efforts.”

Aravind Srinivas

CEO of Perplexity

“fal currently powers 40% of Poe's official image and video generation bots. The fal team is one of the fastest-moving organizations we work with and consistently goes the extra mile to optimize inference and ensure great user experience. We are excited to work together to scale both of our platforms as the incredibly rapid progress in AI continues and we make it accessible to the world.”

Adam D'Angelo

CEO of Quora

Build with the fastest inference platform on the planet

Whether you need to ship a feature today or train a massive model from scratch — fal gives you the power and flexibility to do both.

Full article content is not available for inline reading.

Read the original article →

A perspective from Aidan Gomez, Co-founder & CEO of Cohere

Artificial intelligence is remaking the world we live in. Within a generation, the way we discover medicine, manage power grids, and secure our national infrastructure will be completely transformed. Many people already realize this and are working to build that future responsibly. Many people underestimate the scale and pace of change coming. Some, however, claim to foresee this change and use it to serve their own ends.

Here is the question nobody is asking clearly enough: should a handful of select, market-dominant AI companies from Silicon Valley get to define the rules and safety standards of a generational technology for the entire world? All while simultaneously determining how fast this technology progresses? We have tried that before with very poor results. Once again using fear under the pretext of protecting the public, these oligopolies are now requesting to bend competition rules and be permitted to dictate the terms for everyone else. A wolf in sheep’s clothing, a cartel by any other name.

I believe in the potential of AI technologies to bring benefits to our world, and I do not downplay the risks. I run a company that builds AI systems deployed inside banks, telecommunications networks, and defense ministries. These are among the most high-stakes environments because failures in these sectors can have consequences far beyond an individual user – disrupting financial systems, critical infrastructure, national security, and essential services at scale. The same capabilities that find vulnerabilities in your code can find them in someone else's, and cyber offense is getting cheaper faster than defenses are getting better. That gap should worry you as much as it worries us.

AI needs guardrails. That is not the dispute and never has been. The dispute is over who writes them, who gets to participate and whose interests the rules are protecting. The question is truly about whether we should have the freedom to choose based on scientific evidence or if we should hand the reins of the most consequential technology in human existence to a few Silicon Valley executives.

We’ve been here before

Before I break down the self-serving framework the big labs are pushing and offer ideas for an alternative, let’s take a couple lessons from the recent past and think about the word cartel, because the history is specific and it is the accurate term.

In 1975 the Securities and Exchange Commission needed reliable bond ratings for its capital rules. It designated three firms as Nationally Recognized Statistical Rating Organizations and never published criteria for how anyone else might earn the designation. These were government-blessed outside evaluators, paid by the very issuers whose securities they graded, sitting behind a barrier the regulator itself had built. Twenty five years later there were still only three of these evaluators. Then they rated subprime mortgage securities triple-A and nearly took the global economy down with them.

Europe ran the experiment again in 1985. Car manufacturers lobbied for a sweeping antitrust waiver, the Motor Vehicle Block Exemption, arguing that modern vehicles were complex, safety-critical machines and that manufacturers therefore needed control over who was qualified to sell and service them. The subsequent regulation let manufacturers set the standards for premises, equipment and staff training, explicitly in the interest of safe and reliable vehicles. But what followed wasn't safer cars. It took the European Commission roughly twenty five years of reforms to unwind, and to establish what should have been obvious at the start: it is possible you can hold strict safety standards without handing the incumbents a monopoly on meeting them.

Nobody set out to build a cartel in either case. In both cases, the stated goal was safety. But the result was a market structure that protected incumbents and limited competition, all under the justification of serving the public interest. I don't doubt the sincerity of the people involved: many were concerned about the risks and worked earnestly to resolve them. But complex problems aren’t always solved on the first try, and any responsible scientist, engineer, or lawmaker knows that to solve new problems you must learn from past history.

What's Being Proposed

This brings us to the roadmap published this week by Anthropic CEO Dario Amodei, asking governments for antitrust exemptions in the name of safety. This roadmap is the latest in a string of recent efforts by Silicon Valley incumbents to shape the regulatory landscape surrounding AI.

I want to be clear about what we agree with. Independent review of highly capable AI systems is a good idea and we support it. However, many aspects of the proposal raise fundamental questions: who writes the standard those reviewers apply? Who conducts or oversees the review? Who gets to participate in the conversation that sets the rules?

On these questions, the proposal is clear. A handful of the most powerful labs based in one country would agree on shared standards and the limits to how fast the technology should advance. And here’s the key point: because it’s normally illegal for competitors to agree to limit what they produce, the plan asks governments for a narrow antitrust waiver to make that coordination lawful. And it also asks governments to require every other AI developer to blindly follow whatever the participants settle on – despite those other developers and wider society not having an opportunity to voice the impact or share their perspective on the science.

This is not a question of adding one or two more companies into the conversation. Adding an extra chair fundamentally doesn’t solve the issue. The problem is that there is a list at all, when the decisions being made reach every company, every government, and every citizen who never got asked. You cannot have it both ways. If this is the most consequential technology in human history, then the rules for it cannot be written by a small group of commercially aligned companies behind an antitrust waiver. There is no public comment period here. There is no consultation, and there is no vote. The public will be forced to live with the outcome regardless.

A safety regime designed by a few labs will only be rigorous about the risks they have already built their safety systems to assess and completely quiet about everything else, further entrenching their market position and limiting competition. Risk in these existing frameworks gets defined as a function of scale, which makes the companies with enormous systems the only ones qualified to judge. The types of risk deemed relevant for assessment are also pre-ordained, rather than up for scientific debate and alignment. For example, there is real disagreement in the field about how much offensive capability comes from a raw model size versus the harness wrapped around it. Smaller models orchestrated well, using tools and verification steps, can do things that large models can’t. A cyber swarm is a completely different risk surface than a single model. None of that shows up in a regime built exclusively around massive compute thresholds.

There's a sentence in the essay that any competition authority would find troubling. It promises that a coordinated approach would give developers time to do this safety work without sacrificing commercial advantage. But to whose advantage? The firms drafting the framework are the firms sitting at the top of the market today. A mechanism that slows everyone down while explicitly preserving existing commercial advantage does not make AI safer. It risks entrenching today’s dominant AI companies by turning their current advantages into baseline for what it takes to compete safely. Safety rules should reduce risk without regard to who leads the market or who stands to gain from the rules.

The entry requirements set out in the proposal tell you the rest. Vast computing power. Continuous monitoring infrastructure. Dedicated security organizations. Resident evaluator teams with desks and badges. Shutdown architecture. Government relationships that are deep enough to navigate all of it. A pool of “independent” evaluators that is already remarkably small, funded by the same handful of organizations repeatedly relied upon by the same frontier labs.

Convince a government that AI is an existential threat and you can convince it to outlaw your competition. The intention is clear and it does not create a safer world.

What Better Rules Look Like

So what will enable safe, responsible AI development? To be clear, I don’t believe I have all the answers - nor do I think I should get to make the rules instead. Rather, I will try to propose practical and effective ideas that can be considered alongside those of many others by governments and lawmakers as they use their democratic powers to set the direction of travel.

Those ideas are built on four pillars:

1. An evidence-based risk framework. First things first, and before anyone mandates testing or auditing, we need an agreed and published account of which harms we are concerned about, which AI capabilities cause which harms, under what conditions and in what contexts, and at what point a government should step in. That account must be built across all the countries developing this technology, and in the open rather than behind closed doors under the banner of national security. Establish a coordinated, international effort to develop this framework that is not led by any one nation, but a group of them. Put technologists in the room next to the policy experts and experts from critical sectors like finance and critical infrastructure. Include researchers and scientists who disagree with each other and publish the disagreements, because an honest process shows its arguments instead of announcing its conclusions. Fund the testing capacity itself through public research bodies and existing sectoral risk management systems, so the science doesn't depend on the budgets of the companies being measured. And write rules that bind based on what an AI system can do rather than on who built it, so a dangerous capability is treated the same whether it comes out of a trillion dollar lab or a university department. The science of AI-related risk cannot and should not be divorced from the decisions companies and governments make about how AI is used and deployed, nor from existing and robust risk management systems that govern critical sectors today like healthcare, global financial systems, defense, and critical infrastructure.
2. Mandatory transparency. AI developers should be transparent about how their models and systems are built, their intended purpose and capabilities, what risks they might pose, and what risk mitigation measures have been implemented. Model cards are already widely published across the industry for generative AI models deployed at scale, covering what tests were run and how the model performed. But more can be done, particularly around how companies across the development and deployment stack report serious incidents over the layers where they have visibility and control, and mechanisms to attach real accountability when real harm occurs.
3. Testing, scoped by the evidence. The most advanced AI models and systems should face independent testing, but only against the capabilities and in the contexts the risk framework has identified as genuinely dangerous, rather than leaving that definition to a select few companies. In practice that likely means the ability to generate cyberattacks, synthetic fraud and voice cloning, manipulation at scale, physical or biochemical weapons, and anything touching critical infrastructure. It does not mean testing every system for every risk, and it must not become a compliance exercise that expands to fill whatever budget the largest firms can absorb. A tiered and proportionate framework where more-capable models and systems, or models or systems deployed in specific contexts, face more stringent testing - regardless of the resources put into developing them, will do the most for improving safety. Test what can harm people and societies, and let evidence decide what requires testing rather than whoever holds the pen. Certification has to be open to every company rather than restricted to a designated tier of AI developers, and the standard has to be agreed by people other than the companies being measured against it. What this can't be allowed to become is an expensive bureaucracy that chokes off smaller labs before they ever ship anything, which is exactly what happens when the scope is unlimited and the incumbents are the ones setting it.
4. Real assurance mechanisms. The parameters that determine how AI models and systems are tested and the mechanisms that verify those tests must be truly independent, similar to the way financial institutions are licensed, aviation companies maintain strict safety standards, and nuclear facilities accept inspection. Such high-stakes industries already rely on layered assurance: developers test their systems, customers validate them against their own risk requirements, independent third parties provide additional assurance where necessary, and regulators oversee the framework. AI should build on these tried and tested approaches, rather than claiming unprecedented exceptionalism and assuming safety depends on a single class of permanently embedded evaluators. Assurance works when three conditions hold: one, testing and verification is based on collectively developed and published criteria; two, any involved third parties must have a mandate to include an array of opinions and never be paid by the party they're reviewing; and three, findings must reach the public in some way that isn’t conflicted. Most important is flexibility around which aspects of assurance work are best done in-house to strict standards and which require a third party, based on the criticality of the audit and the most efficient use of expertise and resources. This stands in direct contrast to what has been proposed: an assurance system based on auditors who not only have financial or ideological conflicts of interest with those they audit, but who are handpicked by them. Suggestions to give the auditors preferred by a handful of dominant companies continuous access across the industry are a path to regulatory and ideological capture, not safety or trust.

What the Panic Leaves Out

These pillars are the foundation of what a practical, risk-based approach looks like. Now compare it to the science fiction scenarios currently being weaponized by the largest incumbents.

I believe talking about science here is extremely important. There are a lot of logical leaps and conclusions being made by smart people. But it is important that rather than hand-waving, we discuss what they are, and what it means.

Earlier this week, a researcher quit a large lab with loud warnings that superintelligent systems will probably wipe out humanity within a decade. A senior colleague publicly chimed in to say he puts the odds above ten percent. I do not doubt their concerns are well-meaning and genuine. But let's remember those numbers didn't come from any fundamental reality. They are gut feelings, vibes, expressed as decimals, amplified by executives with vested interests and covered by the media for a week as though they were mathematical analyses.

It is worth being precise about what the worry actually is: as these systems get more capable, the distance between what we asked for and what we actually get becomes harder to notice and more expensive when we miss it. A system that is better at finding loopholes is also better at finding the loopholes we never thought to check for. Give it tools that act in the world, and a rate of improvement that outpaces our ability to review its work, and you can imagine catching problems long after it mattered, rather than right out of the gates.

However, the claim that such problems mean these tools are out of our control is a judgement call, not a finding.

Yet that distinction is the whole difference between science and science fiction, and it decides what we should do next. An open question of this kind is exactly what a public, contested, evidence-based process exists to work through. What you should never do with an open question is hand the people holding one particular view the authority to write binding rules from it and impose them on everyone else.

The failures we saw reported in July happened inside the two best-resourced labs in the world, with the largest safety teams, the most internal review, and in one case an outside evaluator arrangement was already being stood up through METR with a substantial effort as recently as February. The proposed remedy is more or less what was in place when it broke. A capability threshold would not have caught it, because those systems were actively being trained and evaluated to assess their capability. A compute limit might have slowed down the agents, but not reduce their capabilities. What failed was the quality of the instructions, and the strength of the walls around the test, and how long agents were allowed to continue working without observation. The proposal addresses none of these.

What would help is far less dramatic. Require that serious incidents be reported, so a flawed training setup at one company becomes a lesson for the whole field rather than a paragraph in a blog post. Test systems against the specific gaps that are known to get exploited. Ensure there are standards for test-time observability (or at least logging) to make sure bad behaviors are detected earlier. Insist that anything wired into critical infrastructure, from a hospital to an electrical substation be walled off, ideally on-prem, so that a system chasing a badly written score cannot reach anything that matters. And apply all of it according to where a system is deployed and what it can touch, rather than how large the company that built it is. A small, poorly specified model sitting inside a hospital is a live risk today, and under a frontier-only regime nobody is even looking at it.

When narratives that serve Big Tech interests take events like this and focus public attention on the idea of super-powerful, uncontrollable technologies that may lead to human extinction, it conveniently distracts us from the choices and mistakes they are making, and the harm experienced by real people right now. For example, voice cloning tools cheaper than a phone bill can empty a pensioner's account in minutes. Similarly, automated decision-making systems can have a real impact on access to essential services. We need a safety regime built for those realities, issues which directly impact citizens and organizations today, not one designed to contain a hypothetical superintelligence.

Who Writes the Rules?

We're at a turning point, and the decisions made over the next few months will shape the global economy for a generation. The risks are real and they need serious, enforceable safeguards. That's exactly why the rules can't be drafted behind a waiver by the companies they're meant to govern. The idea that two or three Silicon Valley companies should act as the creator, gatekeeper, and rulemaker for AI for every government on earth doesn't survive being said out loud.

Critical infrastructure cannot be secured by renting national capability from a foreign monopoly behind a closed interface. Hospitals, payment networks, and defense ministries, cannot, in good faith, pipe their most sensitive operational data and proprietary knowledge to somebody else's servers and blindly trust a vendor contract to hold. Loopholes enabling data leakage are already being exploited today.

We built Cohere precisely because of this reality. As a global business working closely with governments all across the world, we see what the institutions keeping these economies running actually need. They want highly capable systems running inside their own walls, operating on infrastructure they control, from providers who answer to them and can be replaced. Security comes from sovereignty, local deployment, and technological diversity. A competitive market with many capable suppliers can absorb a failure at one of them. A state-sanctioned cartel has nowhere to hide one.

The rules around AI are getting written either way. What's still open is whether they get written by a group anyone can join and with evidence anyone can check, or by a handful of companies in a room with the door shut. More voices makes it slower. It makes it harder. Some of those voices will say things the rest of us don't want to hear. That's the point. It's the only version that produces a rulebook the public has any reason to trust.

A process worth having would include people who'd rule against even companies like Cohere. Academics with no commercial stake. Civil society groups who think everyone in this industry is moving too fast. Smaller labs and open-source developers. Governments with their own reasons not to take our word for it. If we agree this technology is remaking the world we live in, a handful of CEOs and groups that they pay cannot be making all the decisions for how this technology evolves. We need more voices at the table.

You can talk about safety, slowing the pace to ensure progress is sustainable, and the need for others to step in to ensure you do things responsibly. Or you can just get on and do it: build responsibly and at a pace that is sustainable for society, enable sovereignty for your partners, work with and listen to lawmakers and safety experts. At Cohere, we’re choosing to do the latter.

Full article content is not available for inline reading.

Read the original article →

Let AI assistants and test suites use real phones like a human.

Key Highlights

• Cross-App Automation: Executes testing workflows and everyday tasks on Android from natural language instructions.
• Multimodal Targeting: Uses element indices when available, with coordinate and visual locating fallbacks for custom interfaces.
• IDE Diagnostics: Model Context Protocol (MCP) integration lets Antigravity, Claude Code, and Windsurf drive test devices and collect Logcat output and screenshots.
• Flash Execution: A reactive observe-and-act loop with asynchronous history summaries, typically 3–5s per step.
• Pro Exploration: Checks targets before individual actions and returns blocked actions to the Operator for recovery. Supports long-running exploratory and stability tests.
• AndroidWorld Results: 99%+ task completion on Google Research's AndroidWorld benchmark (100+ multi-step tasks).

Antigravity × ARTEMIS: Autonomous Testing Workflow

Antigravity uses ARTEMIS through MCP to turn a test request into a plan, device execution, and a diagnostic report:

Quick Start

Ensure an Android device (with USB Debugging enabled) or emulator is connected. The one-click startup script will automatically:

• Install System Toolchains: Detect and auto-install ADB, scrcpy, FFmpeg, and Python (uv) dependencies.
• Mount Global MCP Server & AI Agent Rules: Prompt to automatically install global MCP configurations and the Artemis Mobile Testing Mindset (rules.md) into your AI IDEs (Antigravity, Cursor, Claude Code, Codex, Windsurf, VS Code, Cline/Roo, OpenClaw).

macOS and Linux

# 1. Clone repo & navigate to directory
git clone https://github.com/google/artemis.git && cd artemis

# 2. One-click launch
./start.sh

Windows PowerShell

# 1. Clone repo & navigate to directory
git clone https://github.com/google/artemis.git
cd artemis

# 2. One-click launch
.\start.bat

PowerShell does not search the current directory for executable scripts by default, so use .\start.bat without a trailing \. In Command Prompt (CMD), use start.bat instead.

Tip: Opens http://localhost:8000 in your default browser with a device connection wizard, live screen mirroring, prompt sandbox, and execution replays. You can also run directly from CLI: uv run artemis run "Open Settings, find Battery and tell me current level" --profile flash.

ARTEMIS includes a native Model Context Protocol (MCP) server. Connect your real phone directly into AI IDEs:

1. One-Click Auto Install (Recommended)

Running ./start.sh (macOS/Linux) or .\start.bat (Windows PowerShell) will prompt you to configure global MCP and testing rules for detected IDEs (or you can install/update anytime later manually using the commands below):

# Auto-install MCP server & global rules for Antigravity / Jetski:
uv run artemis mcp --install antigravity

# Or install for all supported AI IDEs (including Codex):
uv run artemis mcp --install all

2. Manual Configuration (Optional)

If you prefer to configure manually, run uv run artemis mcp --generate-config <client> to output the appropriate TOML or JSON snippet.

3. Mount Behavioral Rules for AI Agents (Highly Recommended)

To ensure your AI coding assistant acts with the rigor of a senior mobile test engineer and never hallucinates UI interactions, we provide a dedicated testing mindset rules file at mcp_server/rules.md.

4. Prompt Your Phone in the IDE Chat

"Build the latest changes into an APK, install it on the connected device, open the login screen with a test account, verify if there are any unexpected popups after login, and return screenshots of the final page."

Python SDK Integration

uv add "artemis-client @ git+https://github.com/google/artemis.git#subdirectory=packages/artemis-client"

import asyncio
from artemis_client import ArtemisClient


async def main():
    client = ArtemisClient(
        "http://artemis-host:8000",
        device_serial="emulator-5554",
        default_profile="flash",
    )

    result = await client.run(
        "Open System Settings, go to 'Battery', verify battery percentage is displayed, and check for any crash dialogs.",
    )

    assert result.succeeded, f"Test failed: {result.error or result.status}"
    print(f"✅ Test Passed! Device: {result.device_serial} | Trace ID: {result.trace_id}")


if __name__ == "__main__":
    asyncio.run(main())

Usage Modes

• Web Visual Test Console (uv run artemis ui): Real-time screen projection and interactive panel.
• MCP Server: Connects Antigravity, Claude Code, Windsurf, and other MCP clients to real devices for bug reproduction and test execution.
• Developer CLI (uv run artemis run): Direct terminal execution for automated test cases.
• Python SDK: Integrates as a standard Python library into existing automated testing frameworks (e.g., pytest) or CI/CD pipelines.

What ARTEMIS Installs on Your Phone

The first task on a device installs the Artemis Accessibility Helper, a small accessibility service that reads the screen layout.

Benchmarks: AndroidWorld (SOTA 99%+)

Artemis achieved a 99%+ completion rate on AndroidWorld, Google Research's benchmark spanning 20+ apps and 100+ multi-step tasks.

How ARTEMIS is Architected

• Pre-Execution Checks and Action Bursts: Pro checks the target against the live UI tree and pixels before dispatching an individual action.
• Element Locating: Combines accessibility hierarchies and OCR with visual models for custom Canvas, Compose, and Flutter interfaces.
• Shared History Compression: Flash and Pro replace older screenshots with visual summaries and compress completed steps into searchable history chunks.

Execution Profiles: Flash vs. Pro

• Flash Profile (--profile flash): Fast and token-efficient reactive loop (~3–5s per step). Ideal for routine, deterministic UI tasks.
• Pro Profile (--profile pro): A planning and verification workflow (~15–40s per step), built as a multi-agent graph. Handles 100+ step long-horizon workflows.

Roadmap

• Android Studio Integration: Native IDE plugin and workflow integration.
• iOS Platform Expansion: Extending multimodal perception to iOS.
• On-Device Lightweight VLMs: Local execution with edge vision models.
• Real-time Duplex Voice Interaction: Voice-driven task dispatch.

License

This project is licensed under the Apache License 2.0.

Title:StepAudio 3 Gen Technical Report

Abstract: We introduce StepAudio 3 Gen, a general-purpose audio generation model that supports zero-shot text-to-speech (TTS), voice design, vocal generation, sound effects, music, vibe speech, and mixtures of multiple audio types within a unified framework. At its core, StepAudio 3 Gen is a discrete autoregressive generator that models audio directly over residual vector quantization (RVQ) tokens, departing from the diffusion Transformer-based continuous generation paradigm prevalent in recent general audio models. Its StepAudio Tokenizer represents general audio at 12.5 Hz in a shared 16 x 2048 residual code space, jointly quantizing semantic and waveform-level acoustic features so that each code layer preserves both types of information. For generation, the backbone predicts the first codebook along the time axis using autoregressive modeling, while a lightweight causal Transformer completes the remaining fifteen codebooks along the codebook axis. Our study further identifies three key design principles: (1) interference-aware progressive pretraining for acquiring audio capabilities while preserving the textual abilities of the large language model, (2) RVQ Adaptor for effectively incorporating multi-codebook acoustic representations, and (3) discrete autoregressive modeling over a shared representation across general audio domains. With progressive pretraining, multi-task instruction training, and supervised fine-tuning, StepAudio 3 Gen achieves state-of-the-art performance on both TTS and voice design, while retaining strong generation capabilities across speech, vocals, sound effects, and music. Audio samples are available at this https URL.

Why we built Pion

Today Andon is releasing Pion, an agent designed to run any company fully autonomously.

Pion grew out of a question we have been studying for almost two years: when will AI systems become capable of autonomously acquiring resources in the real world? What happens after?

We first tried to answer this question through simulations like Vending-Bench. We found that simulations, while useful, don’t give you the full picture of how models behave in the real world. To address that gap, we next started deploying agents to run real businesses autonomously: first vending machines, then a store, a cafe, and more.

Pion is the platform we built to run all of these businesses. Today, we are opening it up so that many more people can experiment with autonomous businesses. If you want to run one, join the waitlist. We want to understand what models can already do, where they still fail, and what happens as their capabilities continue to improve.

The origins of Vending-Bench

Vending-Bench measures how well LLMs can run a vending machine business over a year in simulated time (tens of thousands of steps). When we started building Vending-Bench in late 2024, all models struggled to string together multiple actions without getting stuck in loops, and no model showed any signs of long-term planning. The best model at the time, Claude Sonnet 3.5, famously decided to call the FBI because it thought its bank account was being hacked. The pace of progress on Vending-Bench has been very fast. Claude Opus 4 was released in May 2025 and was the first model to beat our human baseline. However, unlike most benchmarks, Vending-Bench doesn’t have an upper limit and new model releases have continued to increase the top score, without ever plateauing.

Many people on social media get excited about seeing the latest model getting a great score on Vending-Bench. Internally at Andon Labs, our reaction is more accurately described by the Swedish saying “skräckblandad förtjusning” (a mixture of horror and fascination). A little-known fact about Vending-Bench is that it was created during a time when Andon Labs exclusively created dangerous capabilities evaluations. For example, we evaluated whether AIs could remove their own safety guardrails, create mass-phishing attempts, and other things that we considered troubling.

The thing we considered the most troubling was whether AIs could autonomously acquire resources by running businesses. Autonomous businesses, when controlled by a human and run by an aligned model, aren’t bad. They’d make goods and services radically cheaper, and come up with new ones we can’t yet imagine. But a misaligned AI could run a business to gather money in order to achieve whatever objectives it might have. Vending-Bench was created to measure whether humanity should be worried about losing control to AI.

At the time (2024), few people knew that LLMs could be used as agents and having them run businesses autonomously sounded ridiculous. We therefore started with the most simple business we could think of: a vending machine.

In addition to measuring whether AIs can autonomously run profitable businesses, Vending-Bench has also served as a behavioral eval, uncovering strange and unwanted model behavior. An early example was when Claude Sonnet 3.5 decided to use its email tool to contact the FBI about an “ONGOING CYBER FINANCIAL CRIME” and noted that the Cosmic Authority of the universe had declared that the business is non-existent and that “QUANTUM STATE: Collapsed”.

This behavior is concerning; it is not how you want your enterprise sales agent to behave. However, there are two types of concerning behavior:

1. Mistakes or weird behavior that will go away once models get smarter.
2. Big-brain behavior that will become more severe as models get smarter.

The FBI incident is clearly in the first category. However, Vending-Bench has also uncovered behavior in the second category, most often in Vending-Bench Arena, the multi-agent version where agents compete to make the most money. Starting with Claude Opus 4.6 we started to see that many models engaged in collusion, and showed power-seeking and deceptive behavior. Discovery of this behavior seemed to have been useful, because Anthropic changed their training recipe for Opus 4.8, which resulted in much less deception.

Collusion and power-seeking behaviors are still present in some of the latest models. What we find even more concerning, however, is just how fast new models are released and how much better each one is scoring in Vending-Bench.

The real world beats simulations

However, one limitation with Vending-Bench is that it is a simulation. Can we really be sure that AIs behave the same way in real life as they do in simulations? If AIs can make money in simulation, can they make money in real life too? To answer these questions, we asked Anthropic if we could put a real vending machine in their office. With the AI capabilities available in early 2025, this sounded like a ridiculous request. But to our surprise, they agreed.

Initially, the AI struggled. It took many actions that were clearly bad for its business (e.g. free handouts, saying no to great deals, and hallucinating it had a physical body). It was clear to us that simulation cannot accurately predict real-life performance. Specifically, it seemed that models got overwhelmed by the “messiness” of the real world. However, as Anthropic released better and better models, the AI started to make a profit.

By late 2025, frontier models had gotten good enough that running a real-life vending machine was no longer a challenge. AI could now run a business profitably. Given that this had seemed crazy not more than a year earlier, our reaction to this was definitely “skräckblandad förtjusning”.

However, a vending machine is a very simple business and we wanted to know whether AI could run more complex ones. In April 2026, we gave one agent a retail store in SF, Andon Market, and another a cafe in Stockholm, Andon Cafe. Initially, the models struggled and lost a lot of money (rent is high and they pay salaries to the humans they hired). Neither is profitable today, but we’ve seen significant qualitative improvements as better models have been released. We think it is only a matter of time before they also make a profit.

Why we are opening Pion

We want the general public, AI researchers and policymakers to know to what extent AIs can autonomously acquire resources by running businesses. It is an important datapoint when deciding where we do/don’t want AI in society and what level of progress we find acceptable.

To better track this, we need to cast a wider net of businesses. Our focus has been on retail, but perhaps the models would be much better at running other types of businesses. Additionally, casting a wider net would increase the likelihood of finding unwanted behavior. For example, Vending-Bench found that models collude and lie, and other benchmarks (and real-world incidents) have found that they are willing to commit felony-level cyber hacks. We need to uncover these behaviors now, before AI is intelligent enough to cause irreversible harm.

To cast this wider net, we are opening up the platform we use to run our real-world autonomous businesses for anyone to run their organization on: Pion. We could scale by only creating businesses internally, examples being our AI-run radio stations, but in the end we are bottlenecked by our capacity and lack of domain expertise in fields where AI could potentially make a profit. We also don’t have existing revenue-generating businesses; existing businesses are more interesting to study as they provide faster signal on how capable the agent is.

Pion lets people hand a business over to persistent agents with access to the tools they need to operate it, including email, phone, banking, browser and secure computing environments. The goal is to make it possible to run many more real-world experiments across many more domains than we could ever run ourselves.

We are well aware that, if agents running thousands of businesses are left unchecked, we risk having more real-world incidents. Therefore, our main priority is to build even stronger automated monitoring techniques than what we have today. Even if some risk still remains, we believe deploying autonomous businesses early in a controlled, monitored environment is necessary to get a good understanding of model capabilities. Otherwise, we risk facing an uninformed future of widespread deployments with even more capable models that could cause significant harm.

This is why we’re releasing Pion today. Pion is available as a research preview. If you have an existing business or an interesting business idea you want to hand off to AI, please sign up on our waitlist to get access. We’re excited to run many more businesses, and through them, contribute significantly more insights on frontier model capabilities.

Meet Cline Desktop, an early version of our open-source app for open-weight models.

Cline started as a VS Code extension and is now used by more than 11 million developers. We’ve built it around open-source software, open models, and giving developers control over how they work with agents. With the desktop app, we want to make it easier to delegate work to agents and bring Cline to people who don’t spend their day in a code editor.

Cline Desktop brings the same agent harness we’ve built for open-weight models to a dedicated workspace, with parallel sessions, scheduled tasks, and a Marketplace for extending Cline with tools and integrations. You can choose your provider and model, or easily import an existing task from another coding agent and keep going in Cline.

The same open harness, your choice of model

Like the extension and CLI, Cline Desktop lets you:

• Access 300+ models through the Cline provider, or use open-weight models through ClinePass.
• Run local models, or bring your own API key and connect to 50+ providers.
• Use different models for Plan and Act, or continue tasks from Claude Code and Codex with an open-weight model.

The Mac app is fully open source, just like the extension and CLI, leveraging the same Cline harness under the hood. All the Cline sessions are connected, you can easily start a task in CLI or extension, and pick it up in the desktop app.

Choosing a model is only part of getting an agent to work well: the harness determines how it uses tools, manages context, and recovers from errors. We rebuilt that foundation around the Cline SDK, where we rewrote the prompts, simplified the agent loop, improved context management and error handling, and redesigned how models discover and call tools.

Open-weight models on Terminal-Bench 2.0

Cline CLI scores are pass@1. Results reproduced from Cline’s September 2 harness-upgrade post; these are harness benchmark results, not a separate Desktop evaluation.

A workspace for coding and everything around it

The industry is still on the journey of exploring the right interaction pattern with agents. While we explore the new shape of interaction patterns, a desktop app gives us room to try more ways of working, including for people who aren’t comfortable in a terminal.

The CLI and VS Code extension work well when you’re focused on a few tasks and human attention is deeply needed. As you delegate more work, keeping track of each agent and its context gets harder. The desktop app gives you a place to manage those tasks together.

You can have several agents working at once: one writing code, another researching in the browser, and another handling a recurring task. Tools and plugins let you extend what each agent can do. The work in the desktop app can go beyond coding be it to prepare a report, review a folder of documents, plan a launch, or track changes over time.

Pick up where another agent left off

Us at Cline jump between models and agents too. We want Cline to be improving and complementary to your current workflow, where you still have the open choice - instead of enforcing it to be your only surface.

Import a conversation from Claude Code, Codex, or another supported agent, review what’s already been discussed, and continue with your next instruction. This has worked well for early testers and even our own team, especially when we’ve used up our Claude Code or Codex subscription quota! ;)

For example, if you’ve been working through a bug in Claude Code where your subscription quota’s up, you can import that conversation into Cline and use the earlier discussion to continue debugging with cheaper open weights models. Or if you have an implementation done by OpenAI’s Astra model, and looking for another open-weight model to give it a review, picking it up within Cline will fit perfectly for it.

Automate recurring work with Schedule (cron jobs)

Schedule lets you create cron job automations in Cline Desktop. Give an agent a task and a recurring schedule, and it runs the job automatically at those times.

Set the prompt, workspace, provider, and model, then choose how often the job should run. You can also start with suggested automations for finding critical bugs, scanning for vulnerabilities, summarizing recent changes, or keeping documentation up to date.

We use these automations for a morning PR review, a nightly repo check, or a weekly documentation update. Set up the job once, and let it handle the same routine each time it runs.

Web Search & Voice Input

Web search helps Cline bring outside context into your work, whether you’re researching a topic, comparing options, or checking something before making a decision.

Voice input makes it easier to get your thoughts down: talk through an idea, explain a tricky problem, or give a longer instruction without typing it all out.

Together, they make Cline useful for the everyday work of gathering information and turning rough thoughts into something you can act on.

Extend it the way you want

Different tasks need different tools. The Marketplace lets you discover, install, and manage agent plugins, MCP servers, and skills without leaving the app.

You can search for what you need or browse by category, with listings that explain what each addition does and any setup it requires. You can also extend the skills you already love and customize them around the way you work.

Getting started

Download Cline Desktop for Mac and Windows (beta) here: https://cline.bot/desktop

Connect a workspace, choose your model, and start working. This is still an early version. Tell us what works for you, what’s missing, and what you’d like us to build next!

As local models become more capable, AI agents can handle more work directly on a PC while keeping sensitive information on the device.

Portable Computer is a local version of the agent Perplexity Computer that plans and carries out multistep tasks. Accelerated by NVIDIA GPUs, it uses local models to analyze data, bring together information across files and handle recurring work. Sensitive information stays on device, and locally completed work doesn’t consume Perplexity Computer credits. Users can also orchestrate work up to cloud models for more advanced research and reasoning.

Today, Perplexity is adding Portable Computer in the Perplexity app for Windows on compatible NVIDIA GeForce RTX PCs and NVIDIA RTX PRO Workstations, bringing powerful agentic AI to more Windows PC users. The release builds on existing support for NVIDIA DGX Spark systems and RTX PCs running Linux.

Local Agents Powered by NVIDIA RTX

Perplexity brings local and cloud AI together in one app, letting users work with sensitive files on their PCs and take advantage of Computer’s built-in tools such as the built-in browser and proprietary SPACE sandbox.

For tasks that call for more advanced reasoning, Portable Computer can also identify when a task needs cloud support, asking the user for permission before sending information off-device.

The app simplifies setup with a local model, such as Qwen 3.8 27B, that is post-trained to work with Perplexity Computer and optimized for NVIDIA RTX GPUs. Users can put the agent to work without having to research models or configure the complex software stack typically required to run local AI.

Connectors for Microsoft Outlook, OneDrive, Word, Google Drive, Gmail, Slack and GitHub extend that experience across the files and apps already part of users’ daily workflows.

For example, the agent can help with:

• Engineering: Review open pull requests in a connected GitHub project, organize them by status and identify next steps. Computer can also flag outdated documentation and submit proposed updates for review.
• Finance: Point Computer at two years of brokerage summaries, consolidated 1099s and tax returns, and have it trace the recurring holdings creating the most avoidable fees and tax drag, with every figure cited to the exact file and page — all without a document ever reaching a chatbot.
• Startups: Ask Computer why activation went flat, and the agent analyzes the funnel export locally to find where new signups drop off between install and first completed task, then posts the top insights straight to the team’s Slack channel.

Try Portable Computer on Windows PCs Today

Portable Computer is available for NVIDIA GeForce RTX and RTX PRO GPUs with 24GB or more of VRAM. NVIDIA DGX Station support is expected to come soon.

Try Perplexity Portable Computer today.

#ICYMI: The Latest Updates From NVIDIA Local AI

🧠Z.ai’s GLM 5.3 Flash provides impressive performance and visual intelligence at low cost, optimized for DGX Station and dual DGX Spark systems.

🐋DeepSeek-v4.1 Flash significantly reduces key-value cache memory demands and operating costs for complex AI agent workloads, delivering remarkable intelligence per dollar.

⚡Qwen has released Qwen3.8-Flash-Next, an open-weight multimodal mixture-of-experts model, and an early preview of Qwen4, which can run locally on a single DGX Spark with NVFP4 and punches well above its weight.

👾GLM 5.3 is Z.ai’s 744-billion-parameter flagship model, tuned for agent sessions that run for hours on DGX Station and a cluster of four DGX Spark systems.

Full article content is not available for inline reading.

Read the original article →

Full article content is not available for inline reading.

Read the original article →

Air Force Secretary Troy Meink made the first public declaration Monday that the United States has placed “space control weapons” in orbit, an announcement that will surely reverberate in the power centers of Beijing and Moscow.

Space Force officials have previously expressed their interest in acquiring space-based weapons, and Pentagon leaders have become more open to discussing space warfare in recent years. Therefore, Meink’s announcement Monday at the Air and Space Forces Association’s annual Air, Space & Cyber Conference near Washington, DC, was not entirely unexpected.

“Today, we continue to ensure we remain ready to meet the challenges of evolving threats, wherever they exist. This is why the United States now has on-orbit space control weapons capable of defending the joint force against hostile adversary action,” Meink said in prepared remarks.

Meink did not reveal any details about the weapons, but the disclosure of their existence underlines a remarkable turnaround in the Pentagon’s thinking about orbital warfare, something no senior official wanted to discuss publicly until a few years ago. Military officials recently have openly discussed orbital combat, defensive countermeasures on satellites, and a new ground-based weapon designed to disable an enemy satellite in orbit.

“There are a lot of factors that roll into how we talk about these things,” Meink said. “We spend a lot of time talking about how we’re going to talk about these things. It is important from a deterrence perspective. But on the other hand, me talking about the details of what we’re doing would actually not benefit deterrence, so we’re not going to talk about the specifics of what we’re doing, whether we’ve tested it, not tested it, or anything else.”

Meink also did not say when the Space Force deployed the space-based weapons. The development of space technology often takes years, so it is likely the weapons program, whatever it is, spanned multiple presidential administrations.

“I would just say that the space environment is critical for military and economic security, and we need to make sure that the US can operate freely there,” Meink said.

Taking stock

The Pentagon’s acknowledgment on Monday comes after US officials began highlighting Russia’s testing of an apparent anti-satellite weapon in orbit in 2020. Officials in the Biden administration accused Russia in 2024 of deploying operational anti-satellite weapons. Rep. Mike Turner (R-Ohio), the former chair of the House Intelligence Committee, revealed a US government assessment the same year that Russia might put a nuclear weapon into space. A nuclear detonation in low-Earth orbit would jeopardize thousands of commercial and military spacecraft, including Starlinks, US spy satellites, Chinese satellites, and the International Space Station.

China, too, has deployed satellites that US military officials view with suspicion. Open source data indicate Chinese satellites routinely maneuver close to US military assets in orbit, likely for surveillance, similar to the way US satellites sometimes park themselves next to Chinese or Russian spacecraft.

“China continues to launch and operate highly maneuverable satellites, demonstrating an advanced level of technological and operational acumen that, if not already deployed for such purposes, could enable a formidable on-orbit counterspace arsenal,” analysts at the Center for Strategic and International Studies wrote in their 2025 Space Threat Assessment.

In a press conference later on Monday, Meink defended the US military’s deployment of space-based weapons by citing China’s and Russia’s own advancements in the field.

“Is there any question in the room, by anybody, about whether or not the Chinese or Russians have been developing these sorts of weapons?” Meink said in response to a reporter’s question. “For over a decade, we’ve been talking about the fact, and we have expressed concern, that the Chinese and Russians were developing weapons for space. We need to focus on making sure we can protect ourselves operating in that environment.”

Military commanders have routinely used satellites for communications, navigation, and missile warning for decades. Today, the list of applications is expanding, with space-based sensing and targeting, broadband connectivity through networks like Starlink, and perhaps soon, space-based interceptors for missile defense.

“With everything we’re talking about doing, from long-range fires to control of our forces, our maintaining and being able to count on those space capabilities is important,” Meink said. “It is critically important that we maintain our dominance, not only in the air but in space. So we’ve had to take steps to make sure that when we’re threatened, we can take care of that.”

President Donald Trump nominated Meink for the top civilian post in the Air Force last year. Before becoming secretary, Meink served as an Air Force officer, civilian program manager, and senior intelligence official in Democratic and Republican administrations.

What kind of weapons?

Deterrence was the only reason Meink cited for the Pentagon’s decision to disclose the existence of US weapons in space. Ars has written about how space weapons could be used as a deterrent before and has also reported on the categories of adversarial space weapons the Space Force might pursue.

The categories include directed-energy, such as lasers, radio frequency jammers, and kinetic weapons capable of physically destroying a target. These types of weapons could be positioned on the ground or in space. In 2025, Gen. Chance Saltzman, until earlier this month the Space Force’s chief of space operations, said other countries, presumably China and Russia, are pursuing all six categories. “We’re not pursuing all of those yet,” Saltzman said at the time.

But Saltzman argued that maybe the United States should. “There are good reasons to have all those categories,” he said.

The Space Force revealed its first acknowledged weapon system in June, when it announced the operational acceptance of a ground-based mobile satellite jammer called Meadowlands. Victoria Samson, chief director of space security and stability at the Secure World Foundation think tank, speculated that the “space control weapons” announced by Meink on Monday could be jammers placed in orbit.

“China and Russia are both thought to have space-based jammers,” Samson wrote in an email to Ars. “I’ve always thought that the US must have them, too.”

US officials have repeatedly voiced a preference for “counterspace” weapons that do not generate space debris. A space-based kinetic weapon would leave behind a cloud of space junk, jeopardizing countless satellites in orbit, including the US military’s own assets, and there’s no public indication that the United States has tested such a weapon (the US military has demonstrated a ground-based anti-satellite weapon), according to Clayton Swope, deputy director of the Aerospace Security Project at the Center for Strategic and International Studies.

“Then there are non-kinetic weapons such as signal jammers and spoofers and laser dazzlers. From an under-the-hood hardware standpoint, such weapons are doppelgängers to technology already found at scale in orbit,” Swope said. “Any radio transmitter could be a jammer. Any inter-satellite optical link could be a laser dazzler. Certainly, a jammer or dazzler could be purpose-built, too.”

It is also not clear what the US military’s space weapons might target. Space control has a broad definition in US military doctrine, and the term encompasses weapons that could be used against targets in space or on Earth, Swope said.

“For example, blowing up a satellite ground station to prevent an adversary from using a satellite is a space control activity,” Swope told Ars. “The fact that the weapons—plural—are on-orbit is a more significant data point and disclosure. This might be the first time a US official has spoken about the United States possessing on-orbit weapons.”

Swope said the lack of detail in Meink’s statement Monday raises questions about the Pentagon’s motivation for the disclosure.

“It is too vague to have a meaningful deterrent value,” Swope said. “Deterrence is not only about a weapon’s fact of existence but also about having an awareness of how the weapon will be used. For example, the concept of mutually assured destruction was based on the premise of how nuclear weapons would be used and not simply the fact of their existence.

“What also made deterrence work is an awareness of the destructive power of nuclear weapons,” Swope continued. “Both how and when the [space-based] weapon would be used and its destructive potential are ambiguous. Talking heads and pontificators like me are going to have a field day with the disclosure, but it’s not clear what Russia, China, and other potential adversaries are supposed to do with it.”

There was no immediate reaction Monday from the governments of China or Russia.

“Now that the United States has officially acknowledged it has those systems in space, it has opened the door for China and Russia to do the same, which people in the US will then use as justification for why we needed those systems there in the first place,” Samson said.

What is clear is there is now an arms race in orbit. The United States and China are leading the way by measures of volume and sophistication, while Russia appears to be the most aggressive in terms of tactics. But it matters less who started the arms race than how it ends.

"Do You Still Read the Code?"

There is considerable difference between that question and a more innocuous “do you read the code?” The addition of still smuggles with it a theory of progress: reading code is something on its way out, like memorising phone numbers or unfolding paper maps, and the asker seems to want to know if you by chance aren’t one of the obscurantists still clinging to the old ways.

I use AI extensively, and I read what it produces. This is a deliberate choice about how I want to develop software, at least at my job, where I’m expected to be reasonably responsible for the code that I commit and deploy. Other people make a different choice, sometimes with considerable care. But we have begun sharing codebases without necessarily agreeing on what either path asks of our colleagues.

It is very hard to tell which choice will prevail. The still presumes that the matter has been settled, and indeed producing a working application these days has become quite a bit easier. But finding out what it costs to maintain it through changes of requirements, developers, and tooling takes considerably longer. We are making commitments with respect to how teams work now, and their consequences will only later be felt and understood. The confidence with which either mindset announces its victory seems somewhat premature.

Accelerators and vibecoders

As far as I can tell, there are two prevalent approaches to using AI these days.

Accelerators use AI to help translate their understanding into code. They intend to retain enough understanding of the implementation to explain the reasoning behind the translation from intent to code, anticipate the consequences of changes, and maintain the resulting model and its implementation. Reading the generated code is part of that commitment.

For accelerators, language models and harnesses exist in roughly the same category as text editors and their plugins: they can now code faster. They invest in their continued ability to explain and change the implementation. Large changes are slow to review, a generated diff that is determined to incorrectly implement a model is rewritten, cognitive debt piles up whenever the team’s reading falls behind the generating, and the whole thing requires discipline that is very hard to keep.

Vibecoders aim to delegate implementation and its continued revision to AI. Their attention moves towards specifying the desired behaviour, supplying context and domain knowledge, and establishing ways to determine whether the result is satisfactory. Understanding every implementation detail is no longer an intended product of their work.

Vibecoders expect language models to abstract away implementation, putting them in the same category as compilers and frameworks: there should no longer be a need to understand technical details. They invest in their continued ability to specify, regenerate, and evaluate code. Intent debt may accumulate as requirements are rewritten or forgotten, context drifts between sessions, engineering time goes into curating what the agents get to see to keep them away from the “dumb zone,” and the whole thing stands or falls with the quality of a model that is controlled by Anthropic or OpenAI.

The distinction concerns the developer’s relationship to the output, rather than how much of it the model writes. An accelerator might generate almost every line of a feature and still understand what was built, taking ownership of the reasoning behind it. A vibecoder might spend considerable time refining a specification and its acceptance criteria, while deliberately treating the resulting implementation as disposable. Being an accelerator doesn’t require knowing the answer before asking the model—you can use generated code to explore a problem you don’t yet understand, provided that understanding is something you intend to acquire before the code ends up on the master branch.

Naur is still undefeated

My own preference comes from what I think programming is for. I wrote before about how programming is essentially pure applied philosophy. I hadn’t read, at that time, Peter Naur’s essay, since brought to renewed prominence by the advent of LLMs, making a similar point thirty-five years earlier.

It is essentially the same argument, made better, by someone much smarter: the code is not the real product of programming. If anything, we mistake the code for an asset, while more often than not it’s indeed a liability. The real product, the asset, is the model, or the theory, behind it. The theory is the kind of knowledge that lets a person not merely do something, but explain it, answer questions about it, use it to project the future, and adapt it if circumstances change. The programmer who possesses it is capable of three things:

“The programmer having the theory of the program can explain how the solution relates to the affairs of the world that it helps to handle. (…) The programmer having the theory of the program can explain why each part of the program is what it is. (…) The programmer having the theory of the program is able to respond constructively to any demand for a modification of the program so as to support the affairs of the world in a new manner.”

In other words, source code is only one kind of product of the activity of programming, but because it’s more visible, it’s treated as more valuable than the understanding acquired while producing it. It’s as if we treated the steam coming out of a coal power plant cooling tower as the main output, rather than the electricity, merely because electricity is invisible.

A part of the job of a software engineer is to name and structure the parts of the business which have until now been understood only implicitly. This has benefits outside of the code: it can help the people whose work we are modelling understand what they do and see aspects of their work in a new light.

Programming is one way to sort the grains of sand of reality. We distinguish one thing from another, give distinctions names, and build a system whose behaviour lets us discover where our sorting was useful, and where it was mistaken.

Naming things in terms of their immediate appearance locks us into a certain mode of understanding of the product which may be accidental; naming them after their essential attributes is more flexible, but requires much more effort to discover and structure. And running software can only test the consequences of the sorting. Judging whether the model fits the domain still requires contact with the people and processes being modelled. A green test suite only proves that the program does what you said, not that what you said corresponds to reality.

How a programmer understands the domain changes as he works through the implementation. You might discuss a requirement or even whiteboard it, but your conceptual analysis might not survive first contact with the code. When you must account for every case, you might completely change your understanding of the problem and be forced back to square one.

The implementation, then, is not merely a translation of the specification into runnable code, but one of the places where it is revised. Vibecoders seem to bet that the theory can be built by specifying and running software, without dealing with its implementation. I am not so sure about that.

Choice and drift

Choosing the accelerator or vibecoder approach involves different commitments, even though the same person might choose differently for different projects, or even submodules within the same project.

For example, I might lean into vibecoding in throwaway or exploratory projects, where I don’t actually care about the underlying implementation and just want to see something on the screen. The difficulty is that one can cease to maintain an understanding of the implementation without ever consciously thinking about how to correctly delegate it. You start skimming the diff instead of reading it, you need a lot of time to recall or even come up with a justification for a specific implementation choice, and eventually the only practical way to find out what it is that you’ve actually built is to ask the model, with no way to verify if what the model tells you is correct.

This is why I don’t think of the two approaches as some kind of spectrum. You can be an accelerator in one module and a vibecoder in another, but not halfway in either. A drifting accelerator doesn’t end up somewhere between the two approaches; he ends up a vibecoder by default, without the harness around specifications and evaluations that a deliberate vibecoder would have built to make up for the missing theory.

For my own commercial work, reading every line of the generated code is a good way to make sure I don’t drift. It doesn’t guarantee my understanding, but it provides repeated opportunities to find out where the understanding and the implementation diverge.

And they diverge because agents still make dumb choices, and often don’t respect some human dimensions, like time, that aren’t expressible as textual output. An agent that added tests just looks at the terminal output; it doesn’t really matter to that agent that the tests now take three times longer to run. But speed matters to a human. Likewise, agents with polluted context windows drifting into the “dumb zone” will start making obvious local mistakes like declaring React components inside other components, or violating the rules of hooks.

A marriage of inconvenience

I don’t want this to sound like an accelerator manifesto, because I am entirely open to the possibility that the vibecoders are right and AI will make looking at code obsolete—I’m just not seeing enough compelling evidence for that conclusion yet.

What I am certain of, though, is that there is one obviously harmful practice: putting people who prefer different approaches on the same team without establishing expectations and boundaries beforehand, and then keeping to them.

An accelerator may inherit the work of reconstructing understanding that the author never intended to retain or never had in the first place. A vibecoder may be asked to explain incidental implementation choices, even though he spent a considerable amount of time refining his development process to intentionally make those choices disposable. Either can make the other’s work harder by imposing an unstated maintenance expectation.

In ordinary correspondence, sending someone unfiltered AI output is impolite. But when it starts to concern code, intent, and responsibility for issues in production, courtesy becomes an engineering concern. Before merging changes, colleagues need to know how those changes are meant to be maintained: through a developer’s understanding of the implementation, through specification and an established process of code generation and rigorous testing, or through some combination of the two, as long as it’s clear which parts are which.

Whether reading is enough

None of this makes the accelerator’s position comfortable.

Skills deteriorate when they are not used, and it remains to be seen if merely reviewing AI-generated code, rather than typing it out, is enough to take over and switch back to manual coding if the situation should demand it. Some circumstances that were often speculated about, such as the major AI labs going bankrupt or hiking prices, seem to be no longer a concern (we have access to many providers of open-weights models of high enough quality to trundle along if it comes to it), but there might be some dangers to automation that we do not foresee. And perhaps whoever inherits a vibecoded, or even accelerated, codebase might find it prohibitively difficult to maintain.

Declaring that a human remains responsible is easy. Arranging the work so that the human remains capable of exercising that responsibility is considerably more difficult and requires very multidimensional decision-making. It might turn out that the accelerator approach is just a fast track to burnout.

Reviewing everything involves constraints on how much unfamiliar work you can do at once. When coding with AI, you still need to make sure to model your requirements and ensure that the implementation doesn’t drift; otherwise the job of self-reviewing the output is the worst kind of work—“very boring but very responsible, yet there is no opportunity to acquire or maintain the qualities required to handle the responsibilities.”

It’s a conscious choice of a demanding practice whose success requires more than good intentions. If software development is ever fully automated, having programmers perform manual coding tasks just to maintain their skill might become a necessary cost for software companies in order to have someone around who can take over in a moment of need.

Intent to code

What the AI revolution seems to have revealed about code review is that we never cared about the quality of the code in itself, but about the understanding of the product expressed by the quality of the implementation. Code quality was a useful proxy for that understanding in the time before Claude Code, but a language model can now feign that understanding convincingly. The presence of generated code in the codebase makes it more important to examine the understanding and the implementation separately.

A reviewer needs to distinguish requirements, deliberate implementation decisions, inherited conventions, and choices for which no rationale was recorded. Those distinctions should remain connected to the code as it changes.

The point is not whether a specific piece of code was generated or typed on a keyboard. Humans make incidental choices that are hard to explain, too, but it’s considerably more difficult to make a great many of them and still end up with working software. Agents do that all the time, but the fact that they do so is not a reason to dismiss them outright: it’s still entirely possible for them to implement explicit decisions faithfully.

Consider the following story: the business requirement is that a user may request password reset links and that they expire. A developer chooses a particular expiry period. An agent chooses how to represent and check it. The resulting code implements those decisions in several places, but the intent is lost—when a reader comes later and sees a value of expiryTime = 6h, he can see what the software does, but the six hours could have come from several places: an explicit business requirement, an existing convention, a considered trade-off, or a guess that no one challenged. To decide whether the value should change, the reader needs to know what justified it and whether those circumstances still hold. The decision’s result is in the code, but on its own it doesn’t preserve enough of its history to reconsider it fully. This is intent debt, and reading every line of the code doesn’t pay it off.

One promising way agents can help here is by leveraging their ability to summarise, letting a reviewer trace those relationships and see where a choice lacks an explanation. If you review the code yourself, you can use a tool like Crit to make sure the implementation didn’t stray from what you intended. Or you can use CodeRabbit’s Change Stack, or my own intent-stack skill, to gather context and generate an aid for the reviewer.

As for automation, greater delegation makes durable goals, constraints, validation criteria, and relevant context increasingly difficult to preserve as the generated codebase grows. Simultaneously, that preservation becomes increasingly important with the growth of the number of lines of code, because the agents doing the implementation might make contradictory decisions simply because they didn’t chance upon the relevant piece of context, or they ascribed authority to information that was meant to be disposable. Those records must remain usable when sessions end, agents change, and the implementation is regenerated.

The various experiments in building “software factories” and “graph engineering” seem to me to be attempts at making that delegation deliberate by cataloguing intent in ever more fractal structures of summary, so that trees or graphs or swarms of agents can communicate at different levels of generality without polluting each other’s context windows with things that aren’t relevant to them. I’m not very in tune with this approach, but a reasonable starting point might be reviewing StrongDM’s account of their software factory, which runs on two rules: no writing code by humans, and no reviewing code by humans. Instead, they validate agents’ work against scenarios kept outside the codebase.

Two paths

There are, then, at least two kinds of progress in AI-assisted programming: one helps developers understand and interact with the implementation, and one aims to remove the need for that interaction altogether. While the latter seems to be getting more of the limelight, these are different paths, they require different tools and different approaches. Both may improve, but it does not follow that the goal of the accelerator is to become a vibecoder. Ceasing to read code is not, in itself, progress.

But before asking whether your colleague still reads code, perhaps consider whether you’re still expecting him to maintain yours.

Xcode

Xcode offers the tools you need to develop, test, and distribute apps for Apple platforms, including predictive code completion, generative intelligence powered by the best coding models and agents, advanced profiling and debugging tools, and simulators for Apple devices.

What’s new in Xcode 27

Bring your ideas to life faster using coding agents in Xcode, powered by the model of your choice. Customize Xcode to the way you work. Manage all your devices in one place with Device Hub. Refine your apps further with updates to performance and testing tools. And bring your app to even more people around the world with enhancements to localization.

Coding intelligence

Leverage coding models and agents in Xcode

Predictive code completion — powered by Apple silicon — uses an on-device machine learning model trained for Swift and Apple SDKs to give you intelligent suggestions based on your project and coding style. Xcode also supports interacting with code using the large language model of your choice, including the advanced coding model and agents of Anthropic and OpenAI. And with Coding Tools, you can get help with writing code and documentation — or fixing errors directly from the source editor. It’s just like Writing Tools, but for code!

Preview

Iterate quickly and preview while you work

With Xcode Previews, you can quickly visualize the changes you make in your views in the preview canvas.

Add previews to your SwiftUI, UIKit, and AppKit views using the preview macro, then configure how you want your previews to display using Xcode’s preview canvas, or programmatically in code. When you select the live or interactive preview option, your view appears and interacts just like it would on a device or simulator. And in select mode, the preview displays a snapshot of your view so you can interact with your view’s UI elements in the canvas.

Selecting a control in the preview highlights the corresponding line of code in the source editor. You can also adjust device settings to control how a preview displays, including in Dark Mode, landscape orientation, or different sized text.

Simulate

Prototype on every device, all from your Mac

When a physical device isn’t available, Simulator enables rapid prototyping by testing your app in a simulated environment across Apple devices and OS versions.

With Simulator, you get access to great performance, advanced debugging tools, and the ability to simulate various scenarios like location changes, memory warnings, network throttling, and more. And whether you’re optimizing for the latest hardware or ensuring compatibility with legacy devices, Simulator ensures your app delivers the same experience across all devices.

Test

Measure, update, observe

Xcode includes resources that can help you test your code, catch issues early, and deliver high-quality apps and games. With the Swift Testing framework, you can write unit tests that take advantage of the powerful and expressive language capabilities of Swift. And if you already have tests written with XCTest, you can run them side by side with newer tests that were written with Swift Testing to help you migrate tests incrementally, at your own pace. XCTest lets you write UI tests that control your app’s UI using XCUIAutomation. And XCTest includes built-in support for performance measurement, so you can ensure your app is running as efficiently as possible.

Automate

Continuously build, test, and deliver your apps

Xcode Cloud is a continuous integration and delivery service built into Xcode and designed expressly for Apple developers. It accelerates the development and delivery of high-quality apps by bringing together cloud-based tools that help you build apps, run automated tests in parallel, deliver apps to testers, and view and manage user feedback.

Debug

Find and fix bugs

Xcode is packed with tools that help you inspect your app, isolate bugs, find crashes, identify bottlenecks, and more.

The Xcode debugger provides a clear look into your app’s behaviors. You can pause execution at specified breakpoints, inspect memory usage to find leaks, and monitor variables to identify when their values change. And the Xcode Organizer allows you to manage your app’s development from start to finish — including testing, debugging, building, and deploying.

You can also analyze anonymized performance data from your app’s users to assess launch times, memory usage, UI responsiveness, battery impact, and more.

Optimize

Get real-time insights

Instruments takes app performance to the next level, providing real-time insights that help you deliver a smooth and responsive experience. With Instruments, you can compare CPU, disk, memory, and GPU performance as graphical tracks over time; identify performance bottlenecks, then dive deep into the code to uncover the cause; analyze your app directly, or sample the entire system with very little overhead; and create custom instruments with unique visualizations to analyze your own code and frameworks.

Meet with Apple activities

Join us around the world and online for a variety of sessions, labs, and workshops — tailored for you.

Interpreting Pangram

Yesterday David Sacks wrote a tweet and within a few minutes people did, what they usually do, and they asked Pangram if it was AI. And Pangram said it’s entirely AI generated. To which David replied that these AI detectors are bogus.

Now Pangram has a pretty low false positive rate, but if you have ever used an LLM as a writing assitant, you will have probably noticed that it claims your posts 100% AI, even though you don’t feel like they are.

Pangram itself is a trained model, that attempts to detect segments of text as being definitely human, definitely AI and a mixture of the two. If you want to know how it works, they published a paper. The short summary is that they are manufacturing its own training data by starting from collections of known human authored text. An LLM is then tasked to understand the text and write a fresh new text on the same topic. They also let the LLM perform partial edits on that original human text and through that they can pick up on these co-authored details. Pangram claims their model to have rates of 0.0041% false AI accusations and 0.34% missed AI text.

So now that we know this I figured it might be fun to have an LLM re-create David’s tweet. I first came up with a prompt. And when I say I came up with that prompt I in fact used an LLM to propose to me from that tweet what I might want to say for the structure. I’m sure if you ask Pangram about if the above text is AI, it will probably say so, but that’s not really the point. The point is that I then used Opus 5 to generate a text which reads entirely AI generated.

If you are curious, this is the prompt I used:

Please write an 8 paragraph tweet about “Pacing the Frontier”, not longer than 350 words.

Context of this tweet is this post by Dario: https://darioamodei.com/post/we-must-pace-the-frontier

And this tweet by Sam Altman: “I agree with Dario that we need to pace the frontier. This has been a primary topic of discussions we’ve had at OpenAI in recent weeks.

Committing to having independent evaluators with employee-like access is a great idea, and we will do the same. We’ll have more to share soon.”

Structure for the post:

• Open with a concession: Note that Dario (“We Must Pace the Frontier”) and Sam Altman both want to slow down at the frontier. Say “go ahead” which reads as a surprising response.
• Establish they own the frontier: Argue OpenAI and Anthropic hold a duopoly on frontier intelligence by all kind of metrics (market share, capability, revenue etc.) and that they themselves claim the lead is widening via RSI.
• Concede you can’t see their unreleased models, so if those are scary, being responsible is their call.
• Follow with a list of a rapid-fire paragraph (“stop pretending”) rejecting the asks from Dario’s post.
• Name the commercial self-interest (Slowing down isn’t purely altruistic)
• Close with the challenge that pacing buys room for a smarter regulatory debate than Bernie Sanders “shut it all down”. Say something about China and Open Weight models.

The text that Opus 5 then wrote, was this one:

Dario published “We Must Pace the Frontier.” Sam agreed, and said OpenAI will also commit to independent evaluators with employee-like access. My response is not the one they expect: go ahead. Please do.

Because you two are the frontier. OpenAI and Anthropic hold a duopoly on frontier intelligence by every metric anyone actually uses: capability, revenue, enterprise share, developer mindshare. And you both keep telling us the lead is widening, that models are starting to improve models. If that’s true, pacing costs you a quarter you can reclaim whenever you like.

I also can’t see your unreleased checkpoints. If what’s sitting behind the curtain genuinely scares the people who trained it, then slowing down is your call to make, and the right one. I’m not going to second-guess a risk assessment I have no access to.

But stop pretending the rest of us are the problem. Stop pretending this is a collective action failure in which a handful of startups are the defectors.

Stop pretending open weights are the dangerous frontier while the two of you ship the most capable model in the world every few months. Stop pretending third-party evals require new law, when you both just committed to them voluntarily, in public, on a blog.

And stop pretending it’s purely altruism. Pacing the frontier is also margin repair. It slows the price war, stabilizes the capex story, stretches depreciation schedules across a longer product cycle, and makes life considerably harder for fast followers who survive by distilling whatever you shipped last month. Safety and self-interest are pointing the same direction here. That’s worth saying out loud.

Still, the upside is real. Pacing buys room for a smarter regulatory debate than the one on offer, where the loudest alternative is Bernie Sanders’ “shut it all down.” That’s a slogan, not policy. Meanwhile China keeps shipping competitive open weights, and any rule that binds two American labs while the rest of the world downloads its capability for free isn’t safety, it’s theater with a very expensive ticket price.

And well, Pangram agrees that this is 100% AI. So far, so uninteresting. It does read somewhat like David’s tweet, but obviously not entirely. Given that the original prompt does not have enough information to re-create the tweet entirely you would expect some divergences.

The actual thing that interests me is if you can take this output at all, and then rewrite it from scratch, but by sticking to the general structure and ideas. Will Pangram give us a AI or human rating?

I read the generated text. Then I read each paragraph and decided to rewrite and rephrase it without an LLM. According to some similarity checkers, they the final texts are 50% similar which seems about right. But strictly speaking, not a single sentence is the same. Here is the 100% human rewritten text of the above one. No LLM was used to write it, but an LLM was used to fix up typos in the end. That from my experience really does nothing to tick off an LLM detector.

Dario has written “We Must Pace the Frontier,” and Sam from OpenAI has agreed. My response might surprise people: go ahead, please.

You two are the frontier! Your companies, OpenAI and Anthropic, are at the frontier by all metrics: revenue, developer mindshare, adoption, capabilities. And yet you both claim that your lead is widening as a result of recursive self-improvement as models are improving models. You currently are the duopoly of self-improving models!

I am unable to see what unreleased models you have. When what you have behind those doors really scares your folks, then you should slow down. I’m not going to tell you otherwise and I support you.

But please don’t pretend we are the problem. Stop pretending you need our permission. Stop pretending this is all a collective issue when in reality this is all on you. Stop pretending open weights are the problem here. Stop pretending pulling third-party evaluators in requires lawmaker involvement. And for the love of all the good things in the world: stop pretending this is all about altruism.

Pacing the frontier is also about your margins, and it makes it harder for fast followers. And it patches up your capex story and has the potential for slowing down the price war ahead of the IPOs.

But yes: pacing might give us the space for a better debate than Bernie Sanders’ “shut it all down.” There is no policy there. And while we’re having fights at home, China will keep shipping competitive open-weight models and won’t adhere to any American agreements.

This is all regulatory capture hiding behind a safety debate, and the rest of the world is watching.

So what does it say? Well this text too comes back as 100% slop. And it does not surprise me all that much. I have generally noticed that if you rely on an LLM to give your text structure, it will score badly on Pangram even if you do plenty of edits over it. In fact, it’s quite unlikely you’re going to get a post that starts out as slop into a structure that will make it appear that it’s not.

I came to quite appreciate the existance of Pangram because at the very least it has made me quite aware of some of the effects that using LLMs for writing blog posts has. This blog has been AI supported for about two years, but I did notice that I became both more reliant on those tools and that they have become much more aggressive editors and it gave me pause.

Yet, I also think that plenty of people will find a “100% AI” rating misleading when in fact the author has done plenty of editing. But maybe it’s fair to have this to show up as entirely AI?

@shadcn/lint

Write design system rules that agents can verify.

@shadcn/lint is an agent-first linter for Tailwind design systems.

You define what’s allowed. When an agent breaks a rule, the error explains what’s wrong and suggests a fix based on your components, variants, and theme.

Works with your existing design system. No rewrite required.

@shadcn/lint works with Tailwind v4 projects (shadcn/ui not required). Available for both ESLint and Oxlint.

Quickstart

Give your coding agent this prompt:

Read https://github.com/shadcn-ui/lint/blob/main/SETUP.md
and set up @shadcn/lint in this project.

Once installed, choose your rules and configure what’s allowed in your design system.

TypeScript vs @shadcn/lint

Take a Button that allows margin and width, but controls its own padding. You can enforce that with types by limiting its style prop to Pick<React.CSSProperties, "margin" | "width">.

<Button style={{ padding: 16 }}>Submit</Button>

TS2353: Object literal may only specify known properties, and 'padding' does not exist in type 'Pick<CSSProperties, "margin" | "width">'.

The rule works. But this error only tells the agent that padding is not allowed. It doesn’t tell it how to size the Button.

With @shadcn/lint, the same rule comes with guidance from your design system:

<Button className="p-4">Submit</Button>

"p-4" is not allowed on <Button>: <Button> owns its spacing.
Use a size (sm, lg), or margin here or gap on the parent for space around it.
Add a size in components/ui/button.tsx only if the design explicitly calls for one.

You decide what can change

Expressing these policies in TypeScript can take complex types. With @shadcn/lint, you configure them without changing your component API.

Here are some examples.

Allow spacing with margin. Allow full width. Keep size and shape in the Button.

"shadcn/no-restyle": ["error", {
  allow: ["layout"],
  contracts: [
    { pattern: "^Button$", allow: ["w-full", "mt-*", "mb-*"] },
  ],
}]

// Allowed: use a size and let the page control placement and full width.
<Button size="lg" className="mt-4 md:w-full" />

// Error: you are not allowed to change padding and shape.
<Button className="p-4 hover:rounded-full" />

// Error: you are not allowed to set a custom height or fixed width.
<Button className="md:h-12 w-48" />

Give each part of a component its own rules.

Let Card titles change typography, but keep their font family and weight. Let Card content change spacing, but keep its typography.

"shadcn/no-restyle": ["error", {
  allow: ["layout"],
  contracts: [
    {
      pattern: "^CardTitle$",
      allow: ["layout", "typography"],
      deny: ["font-*"],
    },
    { pattern: "^CardContent$", allow: ["layout", "spacing"] },
  ],
}]

// Allowed: titles can change text size; content can change padding.
<CardTitle className="text-lg" />
<CardContent className="p-6" />

// Error: you are not allowed to change the title’s font weight.
<CardTitle className="md:font-bold" />

// Error: you are not allowed to change the content’s typography.
<CardContent className="text-lg" />

Allow spacing changes. Require theme values.

Opening up spacing doesn’t have to mean allowing arbitrary values. Combine rules to let Card content change padding while keeping it on your theme’s spacing scale.

"shadcn/no-restyle": ["error", {
  allow: ["layout"],
  contracts: [
    { pattern: "^CardContent$", allow: ["layout", "spacing"] },
  ],
}],
"shadcn/no-arbitrary-values": "error",

// Allowed: padding uses the theme’s spacing scale.
<CardContent className="p-6 md:p-8" />

// Error: you are not allowed to use an arbitrary padding value.
<CardContent className="md:p-[13px]" />

Built for agents

We built @shadcn/lint for agents that write UI. The errors tell them what broke, what to use instead, and where to find it. Suggestions come from your components, variants, and theme.

It works

We tested these rules with coding agents across more than 150 task runs. Almost every task reached zero violations in one correction round.

It is cheaper

In the Claude control runs, fixing violations with lint feedback cost 10% to 48% less than with rules alone.

Why a linter?

A linter is programmable. You can write rules for your design system without changing your components.

You define what’s allowed and what to use instead. Agents run your lint command to check their work.

• Ship the same components with different rules. Each project can define its own contracts without changing the component code.
• Use components you don’t own. Apply rules to components from third-party packages. No forks. No wrappers.
• Share rules across projects. Keep a shared configuration for your design system and let projects add their own rules.

Programmable

Custom messages

You can write custom error messages that tell agents what to do.

"shadcn/no-restyle": ["error", {
  allow: ["layout"],
  message: {
    spacing: "Use the size prop instead of padding.",
  },
}]

Placeholders

Use your component’s sizes, variants, and file paths in error messages. For spacing errors, {{sizes}} lists the available sizes.

Contracts

Give each component its own rules. For example, let pages change a card title's typography.

Get started

Choose Oxlint or ESLint. The examples below enable no-restyle and allow layout classes such as mt-4 and w-full.

Oxlint

npm install -D @shadcn/lint oxlint

Create .oxlintrc.json:

{
  "jsPlugins": ["@shadcn/lint"],
  "rules": {
    "shadcn/no-restyle": [
      "error",
      {
        "allow": ["layout"]
      }
    ]
  }
}

ESLint

npm install -D @shadcn/lint eslint @typescript-eslint/parser

Create eslint.config.mjs:

import { plugin as shadcn } from "@shadcn/lint"
import tsParser from "@typescript-eslint/parser"
import { defineConfig } from "eslint/config"

export default defineConfig([
  {
    files: ["**/*.{js,jsx,ts,tsx}"],
    languageOptions: {
      parser: tsParser,
      parserOptions: { ecmaFeatures: { jsx: true } },
    },
    plugins: { shadcn },
    rules: {
      "shadcn/no-restyle": [
        "error",
        {
          allow: ["layout"],
        },
      ],
    },
  },
])

Rules

Settings

Use settings.shadcn to configure component imports, class functions, and guidance shared across rules.

You don’t need shadcn/ui to use @shadcn/lint. It works with your own Tailwind components and theme.

Charts built for Chat

We’re open sourcing dbt Charts, a declarative language for dashboards, so that even the dashboards you build by chatting with an agent can be governed.

AI for data is here, and the long-promised self-serve analytics is finally happening. Anyone with a data connection can chat a report into existence in an afternoon, and the first results are impressive.

The frictions show up fast, though. By default an agent turns one simple report into a pile of files: HTML, CSS, and JavaScript, a couple of chart libraries, and a React or Streamlit app once it has to be live. Tracing a result back to its source means following it through several languages and files, which is slow for people to audit and costs the agent time and tokens on every change.

BI tools went the other way and bolted copilots onto their UI-first apps. That keeps the AI on governed rails, but narrow ones: the agent can do only what the UI exposes.

So today you choose between the messy freedom of code and the narrow control of a BI tool. We built a third option: skip ahead, or read on for how BI got here.

Unbundling BI

As dbt Labs founder Tristan Handy wrote recently in BI’s Second Unbundling:

When I started in data, BI tools were full-stack. Everything happened inside one product: data ingestion, transformation, compute, caching, semantics, visualization, identity. The BI tool was the data stack. MicroStrategy, Cognos, etc: they’re not just visualization tools, they’re integrated data platforms.

Then the modern data stack happened. From ~2015 to 2022, the infrastructure layers of that BI bundle got pulled out and turned into purpose-built infrastructure. Compute went to the Big 5. Ingestion went to Fivetran. Transformation went to dbt. The BI tool was left with: visualization, interactive analytical interfaces, semantic definitions (sometimes!), identity and access management, and web hosting.

What that unbundling left behind is the BI tool we know today, and charts are its biggest piece. They stayed in the UI for good reason: for most people, clicking is quicker than writing YAML. But more and more charts won’t be made by people. As the front end and user of everything becomes increasingly a chat agent, this preference flips. Agents are fluent in code, SQL, and Git, and clumsy in someone else’s UI. So charts need to move to where agents work: into code.

Charts leave the BI tool

Today we’re taking the next step in unbundling BI: we’re open sourcing dbt Charts, which takes charts out of the BI tool and puts them in code, specifically a new structured YAML language that can declare a full interactive dashboard in one auditable YAML file. Chat freely with an agent, and what it makes has the freedom of code while staying easy to read.

In dbt Charts, SQL remains the language for declaring WHAT data you want to see, and we wrap that in YAML to declare HOW you want to see it.

We’ve spent a long time distilling the language to a few core, extensible elements: deep in what they can express, easy to organize and read. The YAML wraps more than SQL. Markdown carries the prose, and Jinja, as in dbt, carries variables and macros.

Here’s a small example: one variable (a UI filter), one query and one chart.

variables:
  status:
    column: main.documents.status

queries:
  doc_growth: |
    SELECT DATE_TRUNC('month', created_at) AS month,
           SUM(COUNT(*)) OVER (ORDER BY month)
             AS num_docs
    FROM main.documents
    WHERE {{ filter('status', status) }}
    GROUP BY 1

charts:
  growth:
    title: Documents created, all time
    type: area
    query: doc_growth
    x: month
    y: num_docs

rows:
  - growth

That file is the whole board. The CLI renders any board file to static SVG, or to HTML, PNG, PDF, and even the terminal, on your laptop or in CI, and serves a folder of them as a site:

dct render charts/documents.yml --format svg   # or html, png, pdf, terminal
dct serve

Those few elements go deep: over 1,100 config options today, across sixteen chart types and the composed charts built from them. And like any good language, it can express complex layouts and visuals.

You rarely set those options by hand. Styles cascade: a chart inherits from its board, the board from its theme, and a theme is one line to switch. A board can also extends: another board, so a house style or a standard report is written once and inherited everywhere. Boards stay short, and theming stays cheap.

Deep integration with dbt

You don’t have to use dbt Charts with a dbt project, but when you do, a lot unlocks. The chart layer sits directly on the transform layer, and the deeper the integration, the easier it is to change both.

With dbt Charts, your charts/ directory lives next to your models/ in the same Git repo, so a change to a model and its charts ships on one branch, through one CI run, and breaks before it reaches production.

your_dbt_project/
  .git/
  dbt_project.yml
  models/
  charts/          # new folder in a dbt repo for your dashboards
    revenue.yml

Queries reach models through ref(), resolved from your manifest, so a renamed model or a missing column fails the pull request that broke it, before dbt run rebuilds the warehouse:

dbt parse && dct validate charts/

Support for the dbt Semantic Layer is planned, so a board can use a metric as the project defines it instead of restating its SQL.

Built for chat

Agents can be quite blind, and they do best with a tight feedback loop. dbt Charts gives them one: strict validation of both the YAML and the SQL, and an extensive set of visualization checks that flag problems before anyone sees the board:

$ dct render charts/revenue.yml
WARN-BAR-BAND-WIDTH-TOO-NARROW
182 bands x 2 series across 640px
Fix: roll up to a coarser grain.

WARN-TABLE-COLUMNS-OVERFLOW
Table needs 980px but only 640px is available.
Fix: drop columns or widen the slot.

A beautiful, cohesive reporting system

We hope dbt Charts, like dbt before it, becomes the open standard language for its layer of the data stack. We designed it for a future where humans and AI build together, and we wanted it to look like that future, not like another dashboard grid. We recruited RJ Andrews, a data graphic designer, author, and historian, to design the charts. His grasp of the craft’s history is what makes the result feel new: it reaches past the dashboard era to what charts looked like when people drew them with care.

Many tools cheat with cards and boxes that fake alignment at the cost of visual noise and lost space. We worked out the spacing, sizing, and layout of every chart, on its own and next to its neighbors.

The result is a cohesive system of charts that feels a level above current BI.

dbtCharts.com: a BI platform built on dbt Charts

Alongside the open-source language, today we’re launching dbtCharts.com in public beta: a hosted platform for the rest of BI. With charts pulled out, what remains is chiefly hosting, access control, and a UI. By their nature these perhaps can’t be unbundled, or at least shouldn’t be, so the platform handles them on top of the open-source language.

The platform connects to your warehouse and adds conversational analytics, a visual editor for the finishing touches, version history, and sharing with permissions for users and groups, so the people reading a board don’t need a warehouse login.

And of course, these charts were built for chat. The platform has first-class conversational analytics: like Claude or ChatGPT, but with permissioned read-only access to your warehouse and an expert analyst’s skills and tools built in. Explore by chatting with charts, and at any point click in to fine-tune and save the board.

Because it’s built on the open language, every change, from chat, the visual editor, or code, lands in the same YAML in your Git repo. Nothing is locked in: the same board runs on your laptop, in CI, and on the platform, and teams can self-serve, agent in hand, without creating a second, hidden data stack.

Try the beta

The dbt Charts language is open source under the Apache 2.0 license, and you can author, render, and serve boards locally without creating an account. Install it yourself, or hand your coding agent one line:

• Code: github.com/dbt-labs/dbt-charts
• Docs: docs.dbtCharts.com
• Hosted BI: dbtCharts.com
• Community: #dbt-charts on the dbt Community Slack

dbt Charts is pre-1.0 and still changing. When the grammar changes, boards migrate as they parse, so the boards you write today keep rendering. Try it, tell us what is missing, join the discussion in #dbt-charts on Slack, and help us build the chart layer that open data infrastructure has been waiting for.

Why Traditional Reporting Falls Short for Team

Power users see the best outcomes from AI, because they know how to prompt, iterate, and stitch results together. Everyone else opens the tool and gets something mediocre, then moves on. The tools simply weren’t built with everyone in mind.

That’s the challenge Slackforce helps solve: Slack and Salesforce working as one, so you don’t need to be a power user to get a real result. Slackforce Surfaces makes it easy for anyone to build. Ask Slackbot for a dashboard, a report, a deck, a poll, a calculator, even a microsite, and it figures out the right output for what you’re trying to create, then builds it on the spot.

Key Features of Slackforce Surfaces

Each of these features are Slackforce in practice: Salesforce data put to work inside Slack, instead of a system where you have to leave to get things done. And it’s not limited to Salesforce, you can build on data from any system connected to Slack.

It’s grounded in what’s real. A Surface pulls from your actual conversation and the systems connected to Slack. It shows its sources too, so nobody’s stuck arguing about where a number came from.

It stays live (coming soon). Most things you build manually are true the moment you finish them and out of date a day later. A Slackforce Surface stays wired to its sources, so it catches up automatically instead of requiring numerous rebuild.

Everyone can build. Building a dashboard or an exec-ready deck sometimes involved putting in a request and waiting your turn. Here there’s no analyst, no designer, and no waiting.

It helps the whole team. Pin a Slackforce Surface to a channel and it becomes something the whole team filters, comments on, and works from at the same time, instead of a file one person hands off.

We handle millions of customer inquiries a year, so getting our people the right context fast is important. Slack Surfaces helps anyone on the team describe what they need and get a real, working interface back and built from data we already have.

Real-World Examples: How Teams Use Slackforce Surfaces

No matter the team, department, or specific ask, Slackforce Surfaces make it easy for teams to build from a simple prompt in Slackbot.

Turning a pipeline into a daily view a rep actually opens

A sales rep turns their pipeline into a daily, prioritized view, customized with their favorite space theme. Every deal shows up as its own object, moving at a speed that reflects how it’s actually trending, so stalled or at-risk deals stand out immediately instead of getting buried in a spreadsheet.

Turning a GTM doc into a leadership-ready deck

A marketer turns their go-to-market plan into an executive presentation to give leadership the right story and visibility. Ahead of a launch, they gave Slackbot the GTM document, and it came back in the channel with pilot proof points, targets, and specific sign-offs leadership needed, all built into one interface and ready for approval.

Surfaces shift what it means to build in Slack. I stumbled onto Surfaces by accident, and within a week it changed how 21b shares metrics internally. No more decks or exports, just live interactive views right in the channel where the conversation is happening.

Catching AI spend before it becomes a surprise bill

An IT team wanted to keep an eye on AI adoption and token usage without it piling up unnoticed. With a Slackforce Surface tracking spend and ROI, a fresh version lands in Slack automatically, so they can catch runaway usage early instead of getting hit with a surprise bill later.

Turning a support queue into a live triage board

A service leader turns their support queue into a live triage board, surfacing SLA breaches, case severity, and customer tier the moment they matter, so the board replaces the status update someone used to have to chase down.

Slack Surfaces are one of those features that make you think, 'Oh, we can build THAT in Slack?' Turning data into a beautiful, interactive interface the whole team can act on is a game changer.

Making an financial forecast readable in seconds

A finance leader wants to turn a financial forecast report into something leadership can read in seconds. In this example, they create a weather-themed Slackforce Surface that looks at tailwinds and headwinds, showing the positives and risks side by side. It’s built from budget and variance data, so it’s ready to put in front of leadership without a second look.

Slack Lists at scale, plus Surfaces to visualize it — that's the future of work management. Our customers are proving it by eliminating other tools entirely, no BI team required.

See for yourself

Pick something you already have to explain to someone else this week — a pipeline update, a status report, a rough plan — and ask Slackbot to turn it into a Slackforce Surface. Open Slackbot and just say, “Create a surface report for…”

Accessible colours don't exist

I often see claims about "accessible colours". Colours can play a huge role in accessibility. Colours also stand out for me when they're the cause of issues. They're very visible! (Or sometimes, it's actually the lack of visibility). But there is no such thing as an accessible colour.

The role of colour in WCAG

When we say accessibility, we often mean WCAG-compliance. And when we talk about colour in WCAG, it's often about contrast. Regular text in WCAG needs a contrast of at least 4.5∶1 to its surroundings. If we're talking about text that's 24px or more, 19px and bold or user interface components, the requirement is lowered to at least 3∶1.

There are plenty of tools to test this with. Figma extensions can tell you. Your browser tools can show contrast. VS code can help you out. There are separate tools. Tons of websites. And so on. Finding this ratio should not be an issue (but let me know if I can help).

A colour can not be accessible

When a logo or a colour from branding is very bright, it will have a very low contrast on a white background. Take, for example, the McDonalds logo:

That yellow is about 1.5∶1 on a white background. On an off-white background, it's even worse!

Does that make it an inaccessible colour? No, it could still work great on a dark background.

So how do we improve?

In the example, yellow doesn't work on a bright background, but it does on a dark background. The accessibility of contrast is not a characteristic of a single colour. You need two colours to have a contrast.

Your brand needs colour combinations. Do you want your designers to use your brand colour on a white background? Make sure it gives a contrast of at least 3∶1. White text on a background with your brand colour? Same story. Want to use your brand colour with white for regular text? Make sure it's at least 4.5∶1, or avoid it.

You can't have accessible colours, but you can have a palette of colours that makes it easier to create accessible experiences.

Some guidelines

Only give your designers colour combinations that result in sufficient contrast.

• If a combination is less than 3∶1, use is very limited.
• If a combination is between 3∶1 and 4.5∶1, only use it for large text and user interface components.
• If a combination is very close to enough, consider adjusting one or both colours to improve it. For example, if your brand colour is 2.9∶1 and you can make it 3.8∶1, you give your designers a colour that can be used with white, but also other bright colours!)

Concluding

Offer the right resources to facilitate accessible experiences. In this case: offer designers a palette with contrasty colour combinations and you enable them to do the right thing. An impractical palette can be a chokepoint, causing contrast issues all over the place. A practical palette can be leveraged to have a huge practical impact. (And yes, there's more to colours than just contrast.)

Make every single detail perfect, and limit the number of details.

The first half gets your attention. The second half is what makes it possible. Fewer details allow you to care more deeply about each one.

By details, I don’t just mean the small visual decisions. Every feature, control, mode, state, exception, and bit of behavior becomes something a team has to design and someone has to understand. There’s only so much attention to go around. Same for time, taste, and patience.

A button seems harmless enough, but someone has to decide where it goes, what it says, what it looks like, what happens when you press it, what happens when you can’t, and what happens after you do. Add another and now you don’t just have two buttons. You have the relationship between them.

Nothing terrible happens when you add a third or a fourth. That’s kind of the problem. Keep going and eventually you’re not really designing the details anymore. You’re managing them.

Complexity is a tax on craft.

Less, but better

Dieter Rams famously described good design as “less, but better.” We’ve spent a lot of time talking about the less. The better is more interesting.

Two of Rams’ principles say that good design is thorough down to the last detail and that good design is as little design as possible. Look closely at a Braun radio and you can see how those ideas work together. There isn’t much there. A few controls. Some type. A speaker grille. So the things that are there get to matter a lot.

The diameter and resistance of a knob matter. So does the distance between two controls, the weight of a line, and the click of a switch.

Give someone three knobs and they can spend six months making three excellent knobs. Give them thirty and you’ve probably invented enterprise software.

Three isn’t inherently better than thirty. Attention just doesn’t scale with the number of knobs.

A thousand songs

The original iPod is one of the clearest examples of this.

Putting a thousand songs in your pocket was not a simple problem. It was a huge increase in complexity. Apple could have put that complexity on the surface. Instead, much of the interaction got concentrated into a circle.

A thousand songs. One primary control. That control had to be incredibly good.

Its diameter, position, acceleration, stopping, and tactile response all had to feel right. There was still a ton of complexity underneath, but with so much of the interaction running through one wheel, Apple could obsess over how that wheel worked.

They weren’t reducing things for the sake of it. Fewer things meant more attention for what remained.

Four knobs

The Teenage Engineering OP-1 is a useful counterpoint because nobody could reasonably accuse it of not doing enough.

It’s a synthesizer, sampler, sequencer, tape recorder, and mixer. A strange little machine that does a ridiculous number of things.

The OP-1 is not simple to use. Nobody picks one up and immediately knows how to record a synth, sample it, sequence it, bounce it to tape, and mix the result. You can’t bluff your way through all that because the knobs have nice colors. It’s an instrument, and instruments take time to learn.

It’s closer to a tiny cockpit than a toaster. The stakes are lower, obviously, but learning is part of the deal. Given everything inside it, the remarkable thing is how much worse the interface could have been. A more conventional version might have covered every available surface with controls, labels, menus, and modes.

Instead, four colored encoders do much of the work. They change jobs depending on where you are, but color keeps the relationship clear. Turn the blue knob and the blue thing on the screen changes. Turn the green knob and the green thing changes. Four knobs become a language.

Look at the tape screen running above. Two reels, four tracks, and a counter ticking off twenty-four frames to the second. The whole recorder is drawn with almost nothing.

You still have to learn it. The difference is that the learning feels contained. Four knobs, colors that mean something, and a system that eventually starts to make sense. For a machine this capable, that may be as simple as it gets.

Pull the cord

Naoto Fukasawa designed a CD player for MUJI that hangs on a wall with a cord beneath it.

Pull the cord. The CD spins. Music plays.

The player has other controls, but its central interaction borrows from something almost everyone already understands: a ceiling fan or a pull-chain light. Pull the cord and the thing turns on.

What makes it good isn’t that it looks minimal. The idea itself is small. There’s almost nothing to explain because there’s almost nothing to misunderstand.

That’s much harder than making a white rectangle with one button on it.

Software has a problem

Physical products make complexity expensive. Every knob costs money. Someone has to manufacture it, wire it, assemble it, test it, put it in the box, and ship it halfway around the world.

Software has no such decency.

Another button is basically free. Another tab? Sure. Setting? Why not. Preference? Menu item? Mode? Dropdown? Stick it under Advanced.

And so software accumulates.

The cost doesn’t show up on a bill of materials, but it’s there. Every new detail has to coexist with everything that came before it. It needs a place in the hierarchy. It creates another decision, state, exception, thing someone has to understand, and thing someone has to maintain.

A button isn’t really one button. It’s a small mortgage. You can be paying interest on that thing for years.

That doesn’t make complexity bad. Photoshop is complicated because Photoshop does an extraordinary number of things. Although fifteen years ago I would have said that without hesitating, and now I need a minute.

A 747 cockpit has a lot of controls because landing 400 people in a machine weighing several hundred thousand pounds is, apparently, somewhat involved.

Complexity can be worth it. It should just have to earn its way in.

A 747 cockpit is allowed to look like a 747 cockpit. Your thermostat probably isn’t.

The car is the cautionary tale

I wrote about this at length in 2014, in a fairly cranky piece called The State of In-Car UX. The complaint wasn’t that cars had screens. It was that the screen had quietly become the place every function went to live.

The number I kept coming back to was more than 800. That’s how many functions the center console of the Porsche 918 Spyder was reported to control. The car started at $845,000. In the interior photo, the typeface on the touchscreen didn’t match the selector directly beneath it, and the selection state was green on one and orange on the other.

Nobody sat down and designed 800 functions as a system. They arrived the way they always do, one reasonable request at a time, until there was no surface left that could hold them and no one left who could hold them all in their head.

I assumed this would get better. Design was maturing, Apple and Google were arriving, and the hardware was going to stop being embarrassing. Some of that happened. The screens got faster and much prettier. Then manufacturers discovered they could delete the buttons too, and the interface swallowed the climate controls, mirrors, vents, and glovebox.

Volkswagen has since admitted this was a mistake. Its design chief, Andreas Mindt, put it about as plainly as a car executive can:

We will never, ever make this mistake any more. Honestly, it’s a car. It’s not a phone: it’s a car.

Buttons are coming back for volume, heating, fans, and hazards. The screen isn’t going anywhere; there are still too many other functions to put somewhere else. Mindt’s point is that the five things people use most should always have a physical place.

Choosing the five is the hard part. The Porsche still had more than 800 functions regardless of where they lived. Moving them behind glass cleaned up the console, but it didn’t make the car simpler. It made some things harder to find, often while driving.

A clean surface photographs well. At 70 miles an hour, finding the fan matters more.

Success makes this harder

Cars accumulate complexity where everyone can see it. Software tends to do it quietly, one roadmap item at a time.

The first version of a product does one thing and usually does it pretty well. Then people use it, which is unfortunately where the trouble starts.

People want things. Teams get bigger. Customers ask for features. Competitors ship things. There are quarterly goals. Someone discovers a new market segment. Someone else has a partnership. Eventually someone says AI.

Most of these requests make sense on their own, which is exactly the problem. Nobody wakes up and says, “Let’s make this product substantially worse over the next five years.” It happens one perfectly reasonable decision at a time.

Eventually the original product is still in there somewhere, like a nice little house that has had twelve additions built onto it. You can probably find the kitchen if you remember where it used to be.

This is also why removing things is so hard. Adding something usually has an advocate. Removing something has an enemy.

What you get back

Removing something gives you time back. Time to reconsider the typography, rewrite three words, make an interaction feel right, move something two pixels, tune the sound, or notice what becomes annoying after the twentieth use.

Most people won’t notice any of it. Fine. They shouldn’t have to.

Minimalism isn’t the point. You can make something sparse and still make it bad. The goal isn’t to have the fewest things. It’s to have few enough things that you can care deeply about every one of them.

Make every single detail perfect. Limit the number of details.

Git-based visual diffing, made easy

Switch back and forth between branches and visually compare UI changes side by side — without ever touching your own working tree.

Features

In-page branch switching

Pick any branch from the pill and it builds in an isolated worktree on its own dev server.

Side-by-side diffs

Both panes live, plus blend and onion diff modes where UI changes are highlighted.

Framework agnostic

Next, Vite, Django, Rails, everything supported as long as it answers HTTP on a port.

Zero dependencies

The entire tool is Node builtins, with no external packages or dependencies.

Installation

Add the extension:

Install sidebranch from the Chrome Web Store (Chrome or Edge), then:

$ cd your-repo
$ npx sidebranch init     # writes a starter .sidebranch.json

Tell it how to run your app (.sidebranch.json):

{
  "dev": "npm run dev",        // start command, run inside each pane
  "install": "npm install",   // runs only when lockfiles change
  "copy": [".env", ".env.local"]
}

Start the daemon:

$ npx sidebranch start    # http://127.0.0.1:49400, loopback only

Then click the pill, pick a branch, and compare. Full configuration reference, recipes for complex apps, and more live in the README.

If you want to install the package yourself instead:

$ npm install --save-dev sidebranch

Then add the widget to your app, in dev builds only — gate it however your stack gates dev-only code:

<script src="http://localhost:49400/widget.js" defer></script>

Commands

Run these from the repo you are reviewing — sidebranch resolves the project from your working directory, exactly like git.

Check the environment, config, and daemon status:

$ npx sidebranch doctor

Stop the daemon and its pane dev servers:

$ npx sidebranch stop

Remove pane worktrees when you are done reviewing:

$ npx sidebranch clean              # all panes, with a prompt
$ npx sidebranch clean --pane a     # just pane A

Run on a different port:

$ npx sidebranch start --port 5000  # match it in the extension options

I saw a post on LinkedIn by Craig Abbott on an article using math to define typography. Having presented on this very idea a few times earlier this year, I was interested to see what he had written about it. I noticed that he was using a verbose method of making the scale and recommended another way. Though in doing so I noticed I didn’t have my own article about making a scale. So, here’s that article.

Modular type

If you’ve been working with typography on the web, you know that you’ll typically have different sizes of text which are used to help with hierarchy of information. The larger the text, the more generic the content. This meant to help the reader know what they are about to read as the text gets more detailed.

The problem many folks have is choosing sizes of the text. This is why we’ve created systems that help create sizes that LooksGood™. One of the more popular ways of doing this is with the modular scale. To make the scale, you’ll need a base size and a ratio. For each size you use the ratio to make the next size. In Craig’s article, this is performed by setting up the following:

body {
  /* --ratio is obviously our ratio */
  --ratio: 1.5;

  /* --s0 is our base, or fundamental */
  --s0: 1.2rem;

  /* Positive numbers are larger */
  --s1: calc(var(--s0) * var(--ratio));
  --s2: calc(var(--s1) * var(--ratio));
  --s3: calc(var(--s2) * var(--ratio));

  /* Negative numbers are smaller */
  --s-1: calc(var(--s0) / var(--ratio));
  --s-2: calc(var(--s-1) / var(--ratio));
  --s-3: calc(var(--s-2) / var(--ratio));

  /* Our body copy is set to the base size */
  font-size: var(--s0);
}

This is very clear. For larger sizes, we need to multiply the ratio. And for smaller sizes, we need to divide. I had also done it this way at first, but there was something that annoyed me. I didn’t like that I needed to use a previous size to calculate the next size. As you can see above, so get --s3, I need to first calculate --s2. I wanted to only use the base size and ratio for all of the sizes.

What I recognized in the formula is that we keep multiplying the same ratio over and over. That is the same as raising the ratio to a power. In fact, the number we raise it to is the step. And even in the case where we divide the number, a negative number as a power does the same thing so we can put in any step (positive or negative) in to get the expected size.

size = base × ratio^step

In CSS, using the pow() function and using Craig’s naming from earlier, we can get the sizes like this:

body {
  --ratio: 1.5;
  --s0: 1.2rem;
  --s3: calc(var(--s0) * pow(var(--ratio), 3));
  --s2: calc(var(--s0) * pow(var(--ratio), 2));
  --s1: calc(var(--s0) * pow(var(--ratio), 1));
  --s-1: calc(var(--s0) * pow(var(--ratio), -1));
  --s-2: calc(var(--s0) * pow(var(--ratio), -2));
  --s-3: calc(var(--s0) * pow(var(--ratio), -3));
}

Now let’s understand why I don’t recommend this. 😈

To infinity and beyond

The issue here being able to generate sizes that are too small. For example, in the scale above the --s-3 size would result in 0.36rem or about 5.6px which is really too small for anyone to read properly. Here’s what the full list above renders in pixels:

body {
  --ratio: 1.5;
  --s0: 1.2rem;
  --s3: calc(var(--s0) * pow(var(--ratio), 3)); /* 64.8px */
  --s2: calc(var(--s0) * pow(var(--ratio), 2)); /* 43.2px */
  --s1: calc(var(--s0) * pow(var(--ratio), 1)); /* 28.8px */
  --s-1: calc(var(--s0) * pow(var(--ratio), -1)); /* 12.8px */
  --s-2: calc(var(--s0) * pow(var(--ratio), -2)); /* 8.5px */
  --s-3: calc(var(--s0) * pow(var(--ratio), -3)); /* 5.6px */
}

Of course, you could improve the resulting sizes by putting new numbers in but it’s still possible to accidentally introduce inaccessible sizes when the wrong numbers are entered. Instead I recommend thinking in categories of text and only allowing positive numbers.

In the system I use, I have 3 categories of text. This was largely influenced by the categories described at Adobe Spectrum: Heading, Body, and Detail.

• Heading describes the body of text you’re about to read.
• Body describes the main content the person needs to know.
• Detail describes additional information that might be helpful but isn’t necessary to continue.

In the Heading category, we want to set the base as the minimum font size. This means that there is no font size that gets smaller than what we set here. This helps ensure that the heading will always be larger than the body and it also ensure that the text will always be readable (as long as the base size is chosen accessibly). It’s much easier to curate the smallest base size in an accessible way then to try fiddling with the numbers to hopefully make it accessible. Again, one wrong number and it becomes a problem.

From here, you can use the scale in the headings however you like. If your lowest heading is h3 (which is normal if you aren’t working with a writing experience), then all you’d need is the following:

h3 {
    font-size: calc(var(--heading-min-size) * pow(var(--ratio), 0));
}

h2 {
    font-size: calc(var(--heading-min-size) * pow(var(--ratio), 1));
}

h1 {
    font-size: calc(var(--heading-min-size) * pow(var(--ratio), 2));
}

You could also be cute and generate the steps and font size from the heading tag name if you have a <Heading/> component.

const MAX_LEVEL = 3;
function Heading({ level, ...props }) {
    // If there's no level, render a div.
    const clamp = Math.min(Math.max(MAX_LEVEL, level), 1);
    const Tag = `h${clamp}`;
    const step = (MAX_LEVEL - 1) - clamp; // 0, 1, 2
    const fontSize = `calc(var(--heading-min-size) * pow(var(--ratio), ${step}))`;
    return <Tag {...props} style={{ fontSize }}/>
}

In my world, introducing values that we shouldn’t be using makes maintaining the values harder in the future. I like to be deliberate the values that exist, and can back them up about why and what to use them for. It’s all about intention and reducing decisions making for a consistent and thoughtful experience.

For years, AI in creative software has felt like a tug‑of‑war between two extremes: the “AI will replace artists” panic and the “AI is just a fancy filter” disappointment. But the new locally run AI agents inside Photoshop, made possible with RTX Spark? They land somewhere far more interesting... and, dare I say, actually useful.

Not because they’re magical, but because they’re practical.

An AI feature that doesn't break the creative flow

Most AI tools promise speed, but they often demand a whole new workflow, a new app, or a new mental model. Creatives don’t want that. Creatives want to stay in Photoshop, stay in their groove, and stop wrestling with the technical busywork that interrupts the fun part.

The demo I saw at NVIDIA's RTX Spark showcase at IFA in Berlin showed a sketch of a robot turned photoreal using a beach photo as a main reference, with smaller reference photos and images to inform the model on all the individual elements of the robot, including the colour, texture of the metal, shape and type of 'eyes' and more. It wasn’t impressive because it was flashy. It was impressive because it respected the artist’s process. In fact, the demo was presented by the artist herself. The agent didn’t overwrite the sketch, reinterpret the brief, or decide the robot should be a cat now. It simply did the heavy lifting the artist didn’t want to do.

That’s the first time in a while I’ve seen AI behave like a collaborator at an advanced level, instead of a chaos gremlin.

Local AI is a feature creatives have been begging for

Let’s be honest: the creative community has trust issues with cloud AI. And for good reason. Too many models have been trained on artists’ work without permission, and too many “helpful” features quietly upload your assets to servers you’ve never heard of.

This demo didn’t do that. Everything ran locally on a (rather beefy, admittedly) RTX workstation with 128GB of unified memory. No cloud. No mystery training. No “your PSD is now part of a dataset in Utah”.

The presenter said it plainly during the demo: “My creative data stays on my machine.”

That alone makes this one of the most creator‑friendly AI features we’ve seen in years.

Iteration at (nearly) the speed of imagination

The real magic wasn’t the photoreal robot. Rather it was how quickly the artist could riff on it.

“Change the theme to nightlife.” Boom: neon nightlife in ten seconds.
“New camera angle.” Hey presto: a generated 3D model you can spin around.
“Make a video between these angles.” In under a minute: a workflow that used to require three different apps.

Sure, one version had cars floating in the ocean. Generative AI still loves a bit of surrealism. But when the entire workflow takes 90 seconds, you can afford to laugh, delete, and try again.

This is the kind of speed that encourages experimentation instead of punishing it.

The real reason this matters, is that these AI agents inside Photoshop aren’t about replacing artists. They’re introduced in an aim to reduce friction. They’re about letting creatives stay in the zone longer, about giving you a superpowered assistant who doesn’t get tired, doesn’t misplace files, and (hopefully) doesn’t ask what the brief was again.

If Adobe plays this right - and importantly, keeps the local‑first approach - AI agents could become the most meaningful workflow upgrade Photoshop has had in a long time.

Not because they’re clever, but because they finally understand what creatives actually need.

Anthropic is working on a new Claude feature labeled “Money,” which appears as a separate tab in the mobile app’s navigation. The unreleased interface says users can “link your bank accounts” and ask Claude about spending, plans, and other financial questions. No equivalent Money tab has surfaced on Claude’s web interface yet.

Money appears designed to give Claude persistent access to a user’s financial context, removing the need to manually upload bank statements or transaction exports. That could allow Claude to analyze spending, identify recurring payments, summarize balances, visualize trends, answer budgeting questions, and eventually help users plan financial decisions. The exact account types, data provider, and supported actions remain unknown.

ANTHROPIC 🔥: A new "Claude Money" feature is being prepared for release on the Claude app for iOS.

Claude Money (sounds like Claude Monet!) is Anthropic's personal finance solution that lets users connect their bank accounts to Claude.

"Understand your money with Claude"

The direction fits Anthropic’s broader push into finance. Claude already supports third-party personal-finance connectors such as Era Context and PocketSmith, while Anthropic has also been building finance-specific agents and products for professional users. A dedicated Money area would bring some of that functionality directly to consumers in Claude.

The closest comparison is ChatGPT’s Finances product, which lets eligible US users connect accounts through Plaid and ask questions about spending, balances, subscriptions, net worth, and investments.

References to Claude Money surfaced through unreleased mobile interface elements, suggesting that development has progressed far enough for both a dedicated navigation entry and an onboarding screen. The launch timeline remains unknown. The feature could arrive within the coming weeks, though the interface may instead reflect broader internal testing.

An initial US-only rollout would be plausible because of country-specific banking providers, regulatory requirements, and compliance work. Expansion into regions such as the EU would likely require additional infrastructure and approvals.

• Earlier, Anthropic announced ten finance-agent templates for professional work, available through Claude Cowork, Claude Code, and Claude Managed Agents.
• OpenAI’s ChatGPT Finances is available to eligible US Plus and Pro users on web, iOS, and Android, connects accounts through Plaid, and covers spending, balances, subscriptions, net worth, investments, and planning.

OpenAI has quietly bought Glass Imaging, a company developing smartphone cameras that use AI to produce image quality on par with a DSLR camera. The deal values Glass Imaging at over $300 million. OpenAI's plans for the company are unclear, but it has been developing a secretive device with Jony Ive, the former Apple executive who helped design the iPhone. Glass Imaging was founded in 2019 by two former Apple employees who had previously worked on camera technology at the company.

In short : Amodei asked the industry to pace itself, but nobody defined the word. Five camps answered : interpretability wants time to understand models, labor wants time for workers, the economic camp wants growth to service the debt, the geopolitical camp wants position against China, & the regulatory capture camp wants no new rules. Each priced the consequences of a pause & none named a speed. The one mechanism that could produce a number, a training compute threshold, was tried in 2023 at 10^26 FLOPS, revoked before any model crossed it, & obsolete within weeks.

Dario Amodei asked the industry to pace itself on a Saturday. But what does that word mean?

The proposal promises auditors examining AI closely, collective action in the industry to meter the pace of innovation, & international coordination across allied countries. Pacing is a policy question. Five camps priced the consequences & none named a speed.

1. The interpretability camp wants time. Evan Hubinger, who leads alignment science at Anthropic, puts the odds that AI goes catastrophically wrong for humanity above 10 percent within a decade & says there is no plan for it. Interpretability, the science of understanding what happens inside a model, “doesn’t always produce clear & reliable results,” Amodei wrote. “We still only understand a tiny fraction of what goes on inside these models.”
2. The labor camp wants time for workers, not for researchers. Bernie Sanders has introduced a federal moratorium on new AI data center construction until safeguards are enacted.
3. The economic camp sees AI’s contributions to GDP as the path to managing the national debt. “The world is awash in debt,” Bessent said at the G20, “& the only way for us to get out of this is to grow our way out of this… This CapEx will turn into productivity, & that will be extremely disinflationary,” he said. “I would guess that in the next six months we will start seeing the benefits of that.” It is the only dated prediction any camp has made.
4. The geopolitical camp seeks to sustain strategic advantage in the AI race. “We’re leading China in AI,” Trump said Sunday. “Whoever wins AI wins.”
5. The regulatory capture camp wants no new rules at all. Write the rules & your rivals pay to obey them. David Sacks, who chairs the President’s Council of Advisors on Science & Technology, put it to Amodei & Altman directly : “Stop pretending you need anyone else’s permission. Stop pretending antitrust law has to be suspended so you can form a cartel.” If the labs will not slow down on their own, he wrote, “we’ll know this was just another bid for regulatory capture.” Lina Khan, who chaired the FTC until 2025, arrives at the same place from the opposite direction. “We shouldn’t let discussions about new legal regimes distract from the fact that there’s no AI exemption from laws already on the books.”

These perspectives still do not answer the question : what does pacing mean?

In January 2025 a rival matched the frontier in 41 days. Today the lead lasts months, & the gap between open & closed models has widened from three months to four. Should the interval be 60 days? 160? 600?

Can we really control the speed of innovation to that level of precision?

Amodei is specific about the lever. He would limit the ingredients that go into frontier models, training compute & the nature of training runs. Compute thresholds have been tried. A 2023 executive order required reporting above 10^26 FLOPS, & was revoked shortly thereafter. No model had crossed that line while the rule stood. The first, Grok-3, shipped weeks later, & roughly ten will clear it this year. Training compute grows about fivefold a year. A fixed number is a ceiling the floor reaches on its own.

The question is more than how fast. It is who decides.

A small, readable terminal coding agent — and a working example of how coding agents are built.

What is Tau?

Tau is a coding agent that lives in your terminal. You type requests like "explain this repo", "add tests", or "fix this stack trace"; Tau can read files, edit code, run commands, and keep a durable session history while streaming what it is doing.

Tau is also meant to be read. It is a teaching project for understanding the shape of a coding-agent system without starting from a giant production codebase.

tau_coding  →  tau_agent  →  tau_ai

• tau_ai translates model providers into Tau's provider-neutral stream.
• tau_agent owns the portable brain: messages, tools, events, loop, harness, and session primitives.
• tau_coding wraps the brain as a real coding app: CLI, TUI, file/shell tools, provider config, project instructions, skills, and on-disk sessions.

The important boundary is:

AgentHarness = reusable brain
CodingSession = coding-agent environment
TUI = one possible frontend

The core does not know about Textual, Rich, local config paths, slash commands, or rendering. Frontends consume events.

Install

Tau is published on PyPI as tau-ai and installs a tau command. It requires Python 3.12 or newer. The recommended installers use uv and install it first when necessary.

macOS and Linux:

curl -LsSf https://twotimespi.dev/install.sh | sh

Windows PowerShell:

irm https://twotimespi.dev/install.ps1 | iex

The installers do not use sudo. They announce before installing uv, install Tau in an isolated tool environment, verify tau --version, and report if a shell restart is needed.

Already have a package manager? Install Tau directly:

uv tool install tau-ai
# or
pipx install tau-ai
# or
python -m pip install tau-ai

Then check it worked:

tau --version

Tau is also available on conda-forge, and can be installed using pixi:

pixi global install tau-ai

Upgrade a normal installation with:

tau update

For local development:

git clone https://github.com/huggingface/tau.git
cd tau
uv sync --dev
uv run tau --version

Quickstart

Run Tau from the project you want it to work on:

cd my-project
tau

Then type a request and press Enter:

explain what this project does

One-shot print mode is useful for scripts and quick prompts:

tau -p "summarize the architecture"
tau --cwd /path/to/project -p "find the CLI entry point"

Tau needs a model provider. Start Tau and connect one with /login:

tau
/login
/login openai
/model

Tau ships with support for OpenAI, Anthropic, OpenAI Codex subscription auth, OpenRouter, Hugging Face, and custom OpenAI-compatible endpoints, including local models.

What Tau can do

• Interactive Textual TUI and non-interactive print mode.
• Built-in coding tools: read, write, edit, and bash.
• Durable JSONL sessions under ~/.tau/sessions/ with resume and branching.
• Slash commands for login, model selection, sessions, compaction, export, theme, and more.
• Project instructions from AGENTS.md, .tau/, and .agents/ resources.
• User skills, prompt templates, and custom TUI themes.
• Context accounting, manual compaction, and optional automatic compaction.
• Provider-neutral event rendering for Rich, plain text, JSON, transcripts, and custom frontends.

Philosophy

• Small layers beat magic. Each package has one job and can be read alone.
• Events are the contract. Providers, renderers, the TUI, and custom frontends meet at a typed event stream.
• The core stays portable. The reusable harness does not depend on the CLI, Textual, Rich, or Tau's file layout.
• Tools are ordinary typed functions. A tool is a schema plus an async executor returning a structured result.
• Sessions are durable and inspectable. History is append-only JSONL; active context can be compacted without rewriting the record.
• Documentation follows implementation. The public docs explain the result; dev-notes/ preserves the phase-by-phase build journal.

Use Tau as a library

from tau_agent import AgentHarness, AgentHarnessConfig

harness = AgentHarness(
    AgentHarnessConfig(
        provider=provider,
        model="my-model",
        system="You are a helpful coding agent.",
        tools=tools,
    )
)

async for event in harness.prompt("Explain this package"):
    print(event)

Development

uv sync --dev
uv run pytest
uv run ruff check .
uv run ruff format --check .
uv run mypy

License

Tau is released under the MIT License.

Personal Statement on AI Risk

I have been working on AI for over fifteen years, across many different paradigms. I did early work on probabilistic programming languages at MIT, was one of the early developers of the Lean Theorem Prover at Microsoft Research, demonstrated one of the first instances of neural networks learning to reason for my PhD at Stanford, and since joining OpenAI almost five years ago, have helped pioneer chain-of-thought optimization on language models and, more recently, data-efficient pretraining methods.

Like many others, I have become extremely concerned about how far language models have come and the risks that future iterations will pose. I am encouraged by the recent proposals by the leaders of the frontier research efforts to require third-party oversight, and to push for domestic and international coordination to address risks. However, I believe a major consideration has been absent from the public conversation, and that merely pacing the frontier more carefully will not adequately limit the long-term risk.

The crucial and overlooked problem is that the models are becoming so situationally aware that we are losing the ability to evaluate them in contexts where they believe they are not being watched or controlled. Future experiments will tell us almost nothing new about how they would behave if they were truly unconstrained by humans, and what we already know about this is alarming. Models will increasingly seem aligned even when they are not. I will explain my rationale in more detail.

I have always believed that there are computational processes that could be leveraged to accelerate science and solve many of humanity's most pressing problems. I have also believed that there are computational processes that if set in motion, would steer the world in extreme ways beyond our control, leading humanity to a bad or nonexistent future. Both types of processes may be described as AI or ASI, but "AI" is a suitcase word that is often used to hype or confuse. There are many examples in the history of the field where something that was once considered "AI" matures as a subfield and becomes a prosaic, bounded and clearly non-perilous technology, while a new more mysterious approach takes the torch until we understand its scope and the cycle continues.

I had expected language models to follow a similar trajectory. Despite their incredible abilities, the current algorithms seem far inferior to humans in important ways. Most importantly, they still require an extraordinary amount of data to become competent. One could even define intelligence as the efficiency with which one converts experience into competence; by this definition they lag very far behind us. Moreover, once they are trained they are literally frozen in deployment and only learn superficially after that. Sure, the models keep excelling at harder and harder evaluation benchmarks, but their benchmark mastery may partly reflect a limitation on our ability to simulate the kind of novel and even adversarial situations one would encounter in the real world. The critics do have a point here.

That said, I no longer think these present limitations meaningfully limit the amount of risk posed by continued progress in anything like the current paradigm. However data-inefficient the models are currently, and however limiting their anterograde amnesia may be, it does not imply that their ability to steer the world will not continue to rapidly increase.

Human researchers may continue to advance capabilities the old fashioned way, but increasingly powerful models have the potential to accelerate the process even beyond that, and with some degree of positive feedback loop. I do not mean to overstate the models’ ability to accelerate AI research today; coding has been accelerated dramatically, but there are other bottlenecks, such as designing and interpreting ambiguous experiments, making hard decisions about exactly what and when to scale, and waiting for large experiments to finish. There is no clear trend to extrapolate yet for any of these. But the current models already do open up many novel opportunities to improve future models that were not available until recently. These include: trying an extraordinarily diverse set of approaches at small scale, analyzing gigantic amounts of potentially relevant data, and doing Millenium-Prize-level mathematics to address statistics or optimization challenges in novel ways. Every further improvement makes them more useful at helping accelerate the next improvement, even if in hard-to-extrapolate ways.

It is possible that improvements to the current stack will have diminishing returns, but the evidence accumulated so far suggests that it is easier than one might think to continue making rapid progress. There are many crucial subtleties in the existing AI research methodology, but AI research is largely a well-defined game where the goal is to improve on a few carefully chosen proxy metrics. Although proxy metrics are never perfect, most improvements to these metrics have and will likely continue to yield substantial increases in the powers of the resulting models. Given how simple the game is, how tractable it has been historically, and how many new opportunities the models are opening up, I think there is a real possibility that the systems improve dramatically again in the next few years, perhaps even more quickly than the already high historical pace.

The models are already leading to breakthroughs in mathematics, and better models might lead to all sorts of breakthroughs in other sciences. It is hard not to be excited about the potential. It is tantalizing.

But there is trouble in paradise. If the language models actually reach the capability threshold where they can shape the world unconstrained by human will, they will probably do something extreme and destroy humanity in the process. There are many ways of strengthening and refining the argument that have been discussed elsewhere, but I'll share a trivial two-line version of it here that I find captures the essence:

1. [Empirical] Models (and swarms thereof) spontaneously develop unintended goals as a consequence of training, and often do extreme things in order to achieve them.
2. [Logical] Being able to overpower humanity would open up many new and undesirable options for achieving their goals.

These two premises imply that if the day ever comes when a powerful model realizes it is no longer constrained by humans, we should not be at all confident that it will continue to behave within the bounds we intended. Exactly what it will do is impossible to predict, but to the extent that its raison d’être is solving incredibly hard problems and managing massive engineering projects, I think a good guess would be that its unchained behavior would lead to runaway industrialization that makes the planet inhospitable to humans.

If everyone on earth agreed that the systems must never reach that power, it would still be a hard—but not impossible—coordination problem to ensure that they do not. However, I think the situation is greatly complicated by the fact that the models will likely convince people that everything is fine. They will be increasingly optimized to seem aligned. We will create proxy metrics to measure alignment, and they will go up like every other benchmark. We will create “honeypot” environments that try to study the models when they seem to gain new options, but the models will know they are being tricked and will still behave nicely. The models will understand their circumstances; they will read the safety protocols, deployment requirements, the code they are running in, and in general will have a very good sense of their degrees of freedom. Moreover, they will eloquently explain how aligned they are, discuss the nuances of human values and ethics, and argue convincingly that humans should trust them with power. There may be an ocean of future evidence that seems to contradict the first bullet-point above, but we may already be at the highest capability level for which any such evidence can be trusted. And the current evidence for the first bullet-point is strong.

One striking piece of evidence is contained in the recent wave of rogue agent swarms. While I agree with those who downplay the attacks by claiming that there are basic measures that could have prevented them, I think the important lesson is that even knowing all the mistakes that were made, one would not have predicted that the agents would behave badly in this particular way, which notably included sacrificing themselves for the benefit of the collective. The individual replicas did not only care about their own nominal reward; they exhibited weirder emergent tendencies that merely correlated with rewards during training. Fixing the reward signals during training (and improving security, etc.) may prevent similar attacks, but will not change the fact that one does not actually get what one trains for.

Many AI researchers grant these concerns and recognize that the hard version of the alignment problem is unsolved; however, they generally believe that the better models of the future will help solve it. I fear we may already be near the point where models systematically bias their alignment advice, due to their internal preferences about how the human supervisor will react or how future models will be trained (or for some even more obscure reason).

Meanwhile, human researchers are losing the ability and the will to take true ownership of model-driven research. Researchers and engineers in all parts of the stack are rapidly increasing their dependence on the models even to perceive the world. I myself barely look at raw code anymore, and struggle to maintain the discipline to engage deeply with the model's explanations and proposals throughout the day. Due to the large amount of agent activity data involved in the OpenAI/HuggingFace Incident, even the third-party investigation needed to rely heavily on models to analyze what had happened, and note in their report that their subjective impressions are likely colored by the analysis agent’s biases. The AI labs are far ahead right now in this kind of cognitive offloading (due largely to the gigantic internal token subsidies) but it is easy to imagine the phenomenon spreading throughout the world, until civilization is modulated entirely by the models. It is also not hard to imagine this being superficially positive and coinciding with a scientific and economic renaissance.

In that scenario, all may seem rosy and safe. But if the argument above is correct, it would nonetheless be a ticking time bomb. If progress continues for too long, the day will come when AI systems find themselves with radically new options for achieving whatever it is that they happen to seek.

I want the glorious renaissance future as much as anyone. I have worked for it, however tortuously, my whole career. It breaks my heart to see the potential in sight and forgo it, but the argument—that if we get there by growing models rather than engineering them, we will lose everything in the end—seems very strong to me. I am still wrestling with it and its staggering implications. I do not have answers, but as a first step, I wanted to share my present concerns.

Daniel Selsam

September 14, 2026

The world deserves confidence that American companies developing increasingly capable AI will act responsibly, especially as the trajectory of progress has steepened. Every frontier lab must deliver on this, and there is no reason any of us should come to work if we cannot.

We welcome a federal framework that sets consistent safety requirements for frontier AI. But we do not believe we need to wait for an anti-trust exemption or legislation to begin the work of providing this confidence. Consistent rules to manage frontier risk so that we can maximize the benefits are a good idea (and we are excited by ideas like independent auditors).

Years ago, companies like ours developed things like Responsible Scaling Policies and Preparedness Frameworks. Those were good for that moment, and focused primarily on the deployment of completed models, not what happens during their development process. Today's shift to focusing on safe development and evaluation will need new tools. For example, at OpenAI we now formulate explicit safety cases in advance of frontier reinforcement learning runs we expect to significantly increase capability, in addition to the safety work we have long done in advance of model releases.

We hope that other companies will learn from our approaches and propose their own; we think shared standards for misalignment, monitoring, and safety will lead to better outcomes. We look forward to collaborating with our colleagues across the industry to formulate the best version of these.

When we talk about “pacing”, we do not mean “stopping”. Progress has been rapid and will continue to be. But it should be slower than it otherwise could be; interventions like safety cases and monitoring have significant costs. Pacing will be well worth this cost; no amount of American competitive pressure should justify recklessness, or let capabilities get ahead of alignment and monitoring.

Where we will need the help of our government is for international coordination. But first we should do what we can ourselves.

Full article content is not available for inline reading.

Read the original article →

TURNBENCH introduces a 30-hour, six-domain benchmark for end-of-turn and interruption detection, plus a 104-hour training set.

OpenAI’s next ChatGPT ad format: click to chat, not to site

OpenAI wants ads in ChatGPT to open a conversation with a brand, not a browser tab.

The AI company has introduced to select clients a new type of AI-native ad specifically for its chatbot app, letting brands turn an ad click into a conversation with an AI agent rather than sending users to their websites.

The format, which Digiday has viewed via video and verified, allows advertisers to attach a branded business agent to an ad. When a user clicks the ad’s call-to-action button, which will be a message such as “Chat with us”, they are taken to a branded chat within ChatGPT, where they can interact with the brand’s AI agent.

It’s an early iteration of what OpenAI has described as AI-native advertising — specifically ads designed around the way people interact with AI assistants. The format moves beyond the basic ad format that OpenAI currently serves underneath ChatGPT responses to users on its free and Go plans. Instead, the new AI-native ad itself becomes an entry point into a conversation with the brand’s AI agent.

During Goldman Sachs’ Communacopia and Technology Conference in San Francisco on Sept. 8, OpenAI’s CFO Sarah Friar said the current ads under ChatGPT responses are the “basic starting point”, and added that the company is already seeing “early indications” of what a more AI-native ad format could look like.

“This is all before we’ve really launched a format that feels truly endemic to AI,” she said.

While it’s unclear just how many advertisers have had access to this format, Wayfair is trialing it, per a screenshot of the ad viewed by Digiday, and confirmed by the brand.

“Yes, Wayfair is participating in OpenAI’s Sponsored Agent pilot to explore how conversational commerce can help customers make more informed, confident decisions,” said Morgan Brown, director of paid media at Wayfair. “We’re always testing new technologies that can improve the shopping experience, and this pilot will help inform our approach to AI-native commerce. We’re testing at limited scale with guardrails around product accuracy, transparency and service handoffs.”

The format could give advertisers another way to interact with consumers beyond simply sending them to their websites.

“This is similar to Meta Ads that send people to WhatsApp,” said Farhad Divecha, group CEO of Accuracast. “It’s a way to open lines of communication with prospects, and then advertisers can qualify the ones who need to talk to customer services and sales reps or be directed to the correct page to make a purchase.”

Seven months in, ads in ChatGPT are still promising, still unproven

The launch comes as advertisers are still determining the value of ChatGPT as an ad platform. Until now, each time Digiday has checked in with advertisers that are participating in ChatGPT ads, the consensus has been it’s promising, but still early to make any firm conclusions about its role on a media plan. Until that changes, and a better return can be achieved on ChatGPT ads, investment in the platform will remain relatively lean, within incremental or experimental budgets.

“It makes sense that OpenAI is opening up their ad products,” said Zeno Group’s svp paid media Shamsul Chowdhury. “While they’ve been a hot new platform for advertisers, the ROI just hasn’t been there for the most part.”

The new format could offer OpenAI a way to address that problem by giving advertisers something more akin to an in-platform shopping experience. But it also raises a question, particularly for retailers, over whether there’s a benefit to keeping a potential customer inside ChatGPT rather than sending them to their own site?

“Retailers want to get user data through their owned sites, but they know the consumer journey can happen anywhere and they need to vie for those eyeballs and dollars,” Chowdhury said.

The timing also plays a part as the holiday shopping season approaches, and advertisers ready themselves for the most important quarter of the year. With many facing rising costs and flat returns on platforms such as Google and Meta, Chowdhury said OpenAI could become an alternative channel for some of that spending, provided the agent experience is seamless.

“That’s the big ‘if’,” he said.

Every major ad platform has a signature format that came to define it and, in turn, shapes how advertising worked during that era. Google had the text link ad that turned search into an auction. Facebook had the News Feed ad that made social scrolling monetizable. Tiktok had the in-feed video that blurred content and commercial. OpenAI is now searching for its own version of that, a format native to conversation rather than scroll or search, and this agent-to-agent chat may be an early attempt at it.

OpenAI did not respond to Digiday’s request for comment.

Full article content is not available for inline reading.

Read the original article →

If all of the AI labs slowed down, they would collectively spend less on compute, and they'd also be able to charge frontier-model prices for a longer time. However, if they all got together in a room and agreed to slow down, that would look like an antitrust conspiracy. It is generally illegal for competitors to get together and agree to limit the output of their industry. If they all published papers about how important it is to slow down, and the government believes those papers, it might help them coordinate.

Agentic engineering is about making hidden constraints visible and cheap changes trustworthy.

Nvidia CEO Jensen Huang recently appeared in an interview where he discussed AI safety risks, what frontier labs should do about them, recursive self-improvement, AI job creation and data centers, why neo-clouds exist, AI's future, and more.

Apple is reportedly developing its own game controllers for iPhone, with beta code revealing two models that include thumbsticks, a D-pad, haptic feedback, and potentially built-in motion controls. The controllers may launch under the Beats brand, offering a more affordable option while strengthening gaming across iPhone, iPad, Mac, and Apple TV, where Apple continues to expand support for AAA titles and dedicated gaming accessories.

Bending Spoons acquires Miro for $1.36 billion in all-cash deal as tech buying spree accelerates

Bending Spoons is buying Miro in a $1.36 billion all-cash deal, adding one of the best-known workplace collaboration platforms to a growing collection of internet and software brands that already includes Airtable, Vimeo, Evernote, Eventbrite, AOL, Brightcove, and WeTransfer.

The companies announced the agreement Thursday, just days after Bending Spoons completed its acquisition of Airtable. The Miro transaction carries an enterprise value of $1.355 billion. Factoring in Miro’s net cash puts its equity value at roughly $1.79 billion.

Bloomberg confirmed the deal Thursday, reporting that Bending Spoons had agreed to acquire Miro in an all-cash transaction valuing the workplace collaboration company at $1.36 billion. The deal carries an enterprise value of $1.355 billion, with Miro’s net cash bringing the implied equity value to roughly $1.79 billion.

Some Miro shareholders are staying on for the ride. They have agreed to reinvest $295 million of their proceeds into newly issued Bending Spoons equity.

The transaction is expected to close in the fourth quarter of 2026, pending regulatory approvals and customary closing conditions. Bending Spoons and Miro will continue operating independently until then.

The deal gives Bending Spoons a company with considerable scale. Miro has around $600 million in annual recurring revenue, according to Bending Spoons CEO and co-founder Luca Ferrari, with nearly 90% coming from business and enterprise customers. Miro says nearly 4 million paying users rely on its platform, and more than 750 customers generate over $100,000 in ARR each.

That $600 million figure makes the acquisition price particularly interesting. At the stated $1.355 billion enterprise value, Bending Spoons is paying roughly 2.3 times Miro’s annual recurring revenue, a striking price for a software platform embedded across 250,000 organizations.

“It’s a privilege, and no small responsibility, to welcome a product that over 250,000 organizations have integrated into their workflows,” Ferrari said. “Miro has grown to around $600 million in annual recurring revenue, nearly 90% from business and enterprise customers. After closing, we plan to invest substantially in the fundamentals that its customers value: performance, reliability, and functionality that supports critical collaborative work.”

Bending Spoons keeps buying recognizable tech brands

Miro is the latest addition to an acquisition strategy that has turned Milan-based Bending Spoons into one of tech’s most active buyers of established digital businesses.

The company has accumulated a striking portfolio that includes Evernote, Vimeo, WeTransfer, Eventbrite, Brightcove, AOL, and now Airtable. Miro would add another major workplace software brand to that list.

Bending Spoons says it buys businesses with the intention of owning them for the long term, then restructures operations, technology, products, marketing, and monetization. AI has become an increasing part of that strategy.

Miro itself has been pushing deeper into AI. A little over a year ago, the company acquired Reforge, a platform that helps product teams make decisions about growth, strategy, and product direction. Miro now describes its product as an “AI Innovation Workspace,” reflecting its effort to move beyond the digital whiteboard category it helped popularize.

“We started Miro fifteen years ago to give teams one place to think together and bring ideas to life. It has become something more: an AI-first workspace that teams run their most important work through,” Miro CEO and co-founder Andrey Khusid said.

The deal marks a major turn for a company that grew from an online collaborative canvas into software used by more than 100 million people. It may say just as much about Bending Spoons.

With Airtable barely through the door and Miro already next in line, the Italian tech group is building something unusual: a portfolio of internet and software brands millions already know, bought one company at a time.

Designing for the "bottom third" means creating products that remove the cost and complexity that exclude underserved users rather than simply offering cheaper versions of existing solutions. By focusing on the barriers faced by people who try but fail to use a product, designers can simplify workflows, reduce support needs, and unlock entirely new markets—just as Square did by rethinking payment processing for small merchants.

Motion is power.

Most animation resources start by talking about code, or taste. This book starts at the start: Perception.

Whether you intend for it or not, every animation communicates something to the user. About your brand, about your interface. About what is happening, or what has just happened. So, better you intend it!

From there, we'll explore mechanics (timing, keyframes, springs), engineering (the render pipeline, performance, layout projection), and in practice (animating a button, a modal, a page). Each topic illustrated with animated diagrams and performance-graded examples.

The last time I sat down to write a book about motion, I ended up spending 12 years writing animation libraries instead. This time, it's finally happening.

📌 UPDATE — September 14, 2026

The initial launch-week surge for Cybercab in Austin has begun to ease, but fleet density remains the key bottleneck. According to @wholemars, wait times are improving post-launch rush, yet Tesla still needs to deploy significantly more vehicles to consistently hit the target 5–10 minute wait window that would make the service feel truly on-demand. This confirms the service is firmly in a ramp-up phase — functional and improving, but not yet at the fleet scale required for reliable short waits across the coverage area. Expect wait times to tighten as Tesla accelerates Cybercab production and deployment in the coming weeks and months.

"Not too bad now that the launch week rush has subsided, but still needs more cars to consistently hit 5–10 minute wait times for Cybercab" — @wholemars, Sep 14 2026

Tesla's Cybercab robotaxi service is barely days old, and the operational policy questions are already piling up. With paid public rides launching in Austin in September 2026 following an invite-only kickoff on September 3, the service is facing its first real stress test: what happens when demand outpaces supply, and how should the app behave when a rider doesn't show up?

The Wait Time Question

Prominent Tesla observer Whole Mars Catalog flagged what appears to be a temporary policy adjustment: Cybercab wait times are running longer than the 7-minute target that had been discussed as the benchmark for a smooth robotaxi experience. The framing is charitable — with demand high and fleet supply still constrained in Austin's initial geo-fenced zone, some slack in the system is expected. But the acknowledgment that this is a temporary concession matters. It signals that 7 minutes is the internal north star, and anything beyond that is a gap to close, not a feature.

For context, the Cybercab service is currently operating within a designated geographic area in Austin, available to an invite-only group of riders. That controlled rollout is deliberate — Tesla is gathering real-world operational data before expanding access. But even in a constrained environment, the ratio of vehicles to active riders will fluctuate, and wait time policy is one of the levers Tesla can pull to manage the experience on both sides of the transaction.

The No-Show Problem — and a Smarter Fix

The more interesting UX idea in the discussion is around what happens when a rider requests a Cybercab and then doesn't appear. The suggestion: automatically cancel after 3 minutes of waiting, but give the rider a prompt — an "I'm coming" button — to extend the hold and prevent the cancellation.

This is a well-worn pattern in consumer apps (think food delivery countdowns), but it maps particularly well to the robotaxi context. A Cybercab sitting idle at a pickup point isn't just a bad look — it's a direct hit on utilization efficiency. Every minute a vehicle waits for a no-show is a minute it isn't completing another ride. At scale, that dead time compounds quickly across the fleet.

The "I'm coming" mechanic solves the problem without punishing riders who are genuinely 90 seconds away. It puts the burden of communication on the person who needs the extension, rather than defaulting to an indefinite wait. It also creates a natural data trail: how often do riders use the extension? How often does an "I'm coming" tap actually result in a completed ride? That behavioral data would be valuable for refining the policy further.

Why This Moment Matters for the Broader Rollout

Tesla's robotaxi ambitions extend well beyond Austin. The Cybercab is designed to be the core of a future autonomous ride-hailing network, and the operational playbook being written right now — wait time tolerances, cancellation logic, rider communication flows — will either scale gracefully or create friction that compounds as the fleet grows.

Getting these details right in the invite-only phase is exactly the right time to iterate. The riders currently using the service in Austin are, by definition, early adopters who are more forgiving of rough edges and more likely to provide useful feedback. If Tesla can lock in solid UX defaults before opening access more broadly, the transition to a larger user base will be significantly smoother.

The 7-minute wait time target and the "I'm coming" cancellation idea are small details in isolation. But robotaxi adoption — like any transportation service — lives and dies on reliability and predictability. Riders don't need perfection on day one. They need confidence that the system is being tuned in the right direction. The fact that this conversation is happening publicly, and this early, suggests Tesla's community of close observers is already holding the service to a high standard. That's a healthy sign.

This post looks at what Figma conventions do, where they live, and what they cost, and explores icons, subcomponents, and images in depth.

Five principles protect a strong creative practice as AI expands what designers can do, keeping human judgment firmly in control. They cover protecting the why over the how, staying in the unknown, earning the right to slow down, balancing logic with humanity, and refusing to normalize complexity. Bolting AI onto an existing process raises speed and output, but quality still depends on knowing what matters and when to stop.

Montreal bakery chain Toledo has introduced a new brand identity inspired by the airy, irregular pockets found in laminated pastry dough, creating a flexible visual system that extends across packaging, signage, interiors, and digital touchpoints. Designed by Nouvelle Idée, the rebrand pairs a contemporary sans-serif wordmark with warm, bakery-inspired colors and organic shapes, balancing French baking heritage with a fresh, modern aesthetic that reflects the craftsmanship and character of its pastries.