OpenAI and Microsoft revised their agreement to increase flexibility, including non-exclusive IP licensing, multi-cloud support for OpenAI products, and capped revenue-sharing terms through 2030.

OpenAI missed its own targets for new users and revenue, raising concern among company leaders about whether it will be able to support its massive spending on data centers. The company's Chief Financial Officer has said that she is worried that OpenAI may not be able to pay for future computing contracts if revenue doesn't grow fast enough. Board directors have been questioning CEO Sam Altman's efforts to secure even more computing power despite the business slowdown. Company executives are now seeking to control costs and instill more discipline in the business.

Analyst Ming-Chi Kuo reported that OpenAI explored building a smartphone with partners like MediaTek and Qualcomm, potentially replacing app-centric interfaces with AI agents and hybrid on-device/cloud models.

China's top economic planner, the National Development and Reform Commission (NDRC), said on Monday it has blocked Meta's $2 billion acquisition of Manus, an agentic AI startup founded by Chinese engineers that relocated to Singapore before Mark Zuckerberg scooped it up late last year.

The move marks one of China's most significant interventions in a cross-border deal, one that extends well beyond U.S.-China tensions and into the broader AI industry. For Meta, it could deal a serious blow to its ambitions in the fast-moving AI agents space.

With no explanation offered, China's NDRC ordered both parties to unwind the deal entirely.

"The National Development and Reform Commission (NDRC) has made a decision to prohibit foreign investment in the Manus project in accordance with laws and regulations, and has required the parties involved to withdraw the acquisition transaction," it said.

But the situation is far from straightforward. Around 100 Manus employees have already moved into Meta's Singapore offices as of March, with founders taking on executive roles. CEO Xiao Hong now reports directly to Meta COO Javier Olivan. Manus CEO Hong and Chief Scientist Yichao Ji are reportedly under exit bans, preventing them from leaving mainland China.

"The transaction complied fully with applicable law. We anticipate an appropriate resolution to the inquiry," a spokesperson at Meta told TechCrunch.

Founded in 2022 by Hong, Ji, and Tao Zhang, Manus relocated its headquarters from China to Singapore around mid-2025. Just months later, Meta came knocking. The company announced its acquisition of Manus in December 2025 for roughly $2 billion to $3 billion, with plans to fold its agent technology directly into Meta AI.

Meta has agreed to acquire Singapore-based AI startup Manus, with the deal requiring a full exit from Chinese ownership and operations, per Nikkei Asia. But the company's origins trace back to China. Manus' founders previously established its parent company, Butterfly Effect, in Beijing in 2022 before relocating to Singapore. That background has drawn scrutiny in Washington, where Senator John Cornyn has already raised concerns about Benchmark's investment in the company, questioning whether American capital should be flowing to a Chinese-linked firm, TechCrunch pointed out, citing Cornyn's post on X.

Manus did not respond to TechCrunch's request for comment.

To Train or Not to Train

The case for and against post-training for application layer companies

Hi friends,

A few weeks ago, I wrote about how AI application companies are increasingly going full-stack, integrating down into the model layer or up into the service layer. Since then, there's been a lot of discussion around the pros and cons of going into the model layer and when the right time is, which will be the focus of today's piece.

To be clear, this discussion is in the context of application-layer companies, not frontier labs. Very few of these companies are pre-training from scratch. Instead, most are post-training and RL on strong open-weights bases.

In this piece, I'll cover:

• The training spectrum
• The case for doing it
• The case against doing it
• When it makes sense, and the new infrastructure that's lowering the bar

I. The training spectrum

"Training your own model" gets used to describe wildly different commitments.

At the extreme end, there's prompt engineering, RAG and harness engineering, which isn't training in any form. A step up, fine-tuning a small model. Further up, supervised fine-tuning or RL on a strong open-weights base as the primary model in the system. Further still, continued pre-training on top of an open-weights model. At the far end, pre-training from scratch.

For application companies, basically nobody is at the far end but as you go right from there, you see examples at the different points. Cursor's Composer 2 builds on Kimi K2.5. Intercom's Fin Apex 1.0 sits on an undisclosed open-weights base. Cognition's SWE-1.5 is, in their words, "end-to-end RL on real task environments using our custom Cascade agent harness on top of a leading open-source base model."

As Intercom's CEO put it, pre-training has become "kind of a commodity" and the action is in post-training. And so most of this piece will be in the context of post-training rather than pre-training.

II. The case for training

In my view there are three real reasons to invest in post-training.

1. Unit economics and latency

Once you're at scale, API calls add up. A smaller specialized model that runs cheaper and returns in 200ms can beat a frontier call that takes 2 seconds and costs 10x as much.

Intercom's Fin Apex 1.0 reportedly runs at roughly one-fifth the cost of frontier models, responds 0.6 seconds faster than the next-fastest competitor, and resolves customer issues at a higher rate. At the scale of a company like Intercome doing ~2M conversations per week, that gap in latency and unit economics is meaningful.

There's a related destiny argument: if your unit economics depend on one frontier API, you're exposed to pricing changes, rate limits, and the provider showing up in your category. No one has felt this more than Cursor, which despite tremendous success and usage, reportedly has -21% gross margins, and has found it difficult to compete with Claude Code when Anthropic's limits supports thousands of dollars of equivalent compute in their $200 max plan.

2. Differentiation through proprietary data

If everyone is calling the same frontier API, where's your edge? Increasingly, it has to come from the traces you've accumulated.

Cursor sees which completions get accepted and rejected. Intercom has billions of customer-service interactions. OpenEvidence has the queries and citations of 40% of US physicians and trained a domain-specialized model which captured data from peer‑reviewed medical literature via their partnerships. That's proprietary training data and the best way to put it to work is through training or post-training.

In some ways, the real vaue of the application layer is that they get the best telemetry on the real use cases of their customer base, far better than any off-the-shelf evals can measure.

And by leveraging those to post-train models allows them to actually improve performance for their users while also getting the latency and unit economics benefits outlined above.

For example, Cursor's Composer 2 was in part optimized on their internal eval Cursor-bench which they created based on their real traces. They felt this benchmark was more representative of the real work developers were doing within their platform than the publicly available benchmarks.

3. Specialized models for the parts frontier labs don't prioritize

Most application companies aren't just training one big custom model to replace the frontier. They're running systems of small specialized models, each fine-tuned for one part of the pipeline that the frontier labs don't optimize for.

Decagon talks about this: smaller fine-tuned models for query rewriting, routing, and intent classification, with a frontier model only where it's actually needed. Sierra trained custom search models (Linnaeus and Darwin) inside a constellation that still uses OpenAI, Anthropic as core models. Cognition has SWE-grep for context, SWE-check for bug detection, SWE-1.5 for the main agent.

Most of the value is in the boring parts of the pipeline (voice activity detection, query reformulation, retrieval ranking, tool selection). None of these need a frontier-grade reasoner. All of them benefit from being faster, cheaper, and tuned to your specific data.

This is a great way to step into fine-tuning and post-training for many companies: train where the frontier underserves you and keep using the frontier where it doesn't.

III. The case against

The biggest reason to be careful: your post-trained model may not survive the next base-model release from the lab. The labs are now releasing new models faster than ever, because the labs themselves are using their own models to build the next ones.

Anthropic's Dario Amodei has said that 70-90% of the code for new Claude models is now written by Claude itself. OpenAI was even more direct in their GPT-5.3-Codex announcement (now 0.2 generations behind :)):

"GPT-5.3-Codex is our first model that was instrumental in creating itself. The Codex team used early versions to debug its own training, manage its own deployment, and diagnose test results."

What this means: model releases that used to take months are now arriving weeks apart. OpenAI shipped GPT-5, 5.2, 5.3, 5.4, and 5.5 within months.

For an app company, that's the biggest risk. A lot of fine-tuning wins from 2022-2024 dissolved when GPT-4 and Claude 3.5 came out, and the cycle is faster now.

That's why in general, it's much safer to post-train or fine-tune specialized models that work in a system of models rather than the core reasoning model for frontier tasks since the cost and latency benefits of those are more likely to survive even as base models improve.

There are other costs to consider as well namely that post-training talent is scarce and expensive. The opportunity cost of the talent and capital used to post-train models could be better deployed or leveraged in other aspects of the product and company.

IV. When to do it

One useful proxy is to train when you have enough proprietary traces to make a small specialized model meaningfully better than the frontier on a specific part of your pipeline.

I should note that the bar to start is also lower than it was a year ago, because a new infrastructure layer has shown up to support post-training in different forms.

• Tinker from Thinking Machine Labs is a managed post-training API. They handle distributed training and LoRA infrastructure while you bring data, algorithms, and environments. As Andrej Karpathy's noted: it lets users keep about 90% of the algorithmic control while removing about 90% of the infrastructure pain.
• Prime Intellect's Lab is similar, hosted RL training plus an open Environments Hub with hundreds of community-built RL environments.
• Applied Compute, founded by ex-OpenAI researchers, is a more white-glove version, post-training on enterprise proprietary data using RL environments and is one of many companies offering some version of RL-as-a-service.
• Vendors such as Mercor, Surge AI, Fleet and others sell custom expert-authored RL environments
• Lastly, the Chinese labs and their open-source base models that are competitive with the frontier closed source models serve as a starting-off point for many.

I do think the improved infrastructure has meant that even small teams of 10-20 can now post-train if they want to. But one mantra I like that still holds true for most application layer companies is "no GPUs before PMF." If you don't have the product or the traces yet, training a model to do that product is premature.

Post-training should be part of the conversation once a company is either rapidly scaling and has collected enough traces or at least has PMF and feels underserved by the frontier in some specialized aspects of their product which they feel the base model can fix.

Closing Thoughts

The companies integrating down into the model layer (Cursor, Intercom, Sierra, Decagon, Cognition, OpenEvidence) aren't doing it because they like training models. They're doing it because at their scale, with their traces, the economics and differentiation arguments finally pencil out. And almost all of them are doing it as post-training, not pretraining from scratch.

For most app companies earlier in their lifecycle, the honest answer in 2026 is: not yet, but start setting up to. Build the data collection now (traces, evals). Start with one small specialized model in a boring part of your pipeline rather than trying to replace the frontier on the main reasoning call.

The durable training investment is the data and environments you accumulate, which let you keep producing better models as the bases under you keep improving. And remember, those base models are improving faster than ever.

If you're working on an AI application or thinking about this tradeoff, feel free to reach out at tanay at wing.vc.

What does an agent harness feel like when every model turn goes through Anthropic's Batch API instead of the synchronous endpoint?

Batches are 50% off. For anyone burning real money on agents (eval suites, background subagents, anything that runs unattended), half-price tokens are the kind of number that makes you stop and squint. The trade is latency: batches are asynchronous, with up to a 24-hour processing window.

So I built a tiny harness to find out what that actually feels like. The result is batching-harness, a single-file Python REPL that wraps every turn in a one-entry batch, polls until it ends, and runs the tool loop on top. About 800 lines. rich for the terminal UI, sandbox-runtime (bubblewrap on Linux, Seatbelt on macOS) to keep the bash tool from nuking my home directory, and a /stats panel that compares what I paid via batch against what I would have paid via the synchronous endpoint. The sandbox setup here is intentionally minimal: just enough to keep an experiment from going sideways. For real execution-layer security for AI agents across models, harnesses, and frameworks, that's AgentSH, my main project.

What I actually wanted to know

The experiment isn't whether the Batch API works. Anthropic's docs cover that fine. The interesting question is what the agent loop looks like when every turn is async.

So you sit at the prompt. You type something. The harness submits a one-entry batch and shows you a spinner with an elapsed counter. A minute or two later (usually 90 to 120 seconds), the batch ends. The model returns either text or a tool_use block. If it's a tool call, the harness runs it locally and submits another batch. Repeat until end_turn.

That's it. The entire experience is "agent, but with a two-minute polling spinner between every turn."

Which is the wrong way to use batch. And that was the point.

What I observed

With parallel=1 (one request in flight at a time, like this harness), you lose most of the actual benefit of batching. You get the 50% discount, sure, but you're paying for it in wall-clock time on every single turn. Ninety to 120 seconds per turn turns a five-turn agent loop into a ten-minute exercise. For an interactive agent, that's terrible: nobody wants to wait two minutes to be told "I need to run ls."

There's also a counterintuitive thing I noticed and didn't expect: Haiku batches tend to take longer than Sonnet or Opus batches. One possibility (and it's just a guess) is that Haiku runs so fast on the synchronous path that there are simply fewer idle windows where the batch scheduler can slot work in. The cheaper, faster model ends up being the worse fit for batching, at least at the single-request volumes I was throwing at it. I haven't benchmarked this rigorously; it's a vibe from a few hours of poking. But if you were building routing logic on top of this, it's the kind of thing that would matter. You'd probably want to avoid batching Haiku and reserve the async path for the bigger, slower models where the queue wait is a smaller fraction of total turn time.

Which actually flips the usual intuition. If you're already eating the latency, you should point the async path at the smart models. The 50% discount has much more absolute leverage on Opus than on Haiku, and since speed isn't the binding constraint anymore, the case for picking the cheaper, dumber model evaporates. You take the better answer instead. The conventional "use cheap models for offline work" gets inverted: cheap fast models stay on the sync path; expensive slow models go to batch.

When batching actually pays

The 50% discount is only worth the wait when something else is going on:

• You don't care about latency. Overnight evals, scheduled audits, anything where "done in an hour" is fine.
• You're running many agents in parallel. If you have 20 subagents working concurrently, batching them together (real batches, not single-entry ones) is where the throughput-per-dollar curve actually bends.
• You're amortizing across multiple harnesses. Same idea, scaled out: pool requests from many independent agents into shared batch submissions and the economics start looking very different.

The third one is the part I find genuinely interesting. A single user at a single REPL is the worst case for batching. But a fleet of agents (your CI runs, your background research subagents, your team's automated workflows) could be pooled by a smart proxy and submitted as actual N-wide batches. That's a real cost lever, not a curiosity.

There's also a compounding effect with prompt caching that gets sharper at fleet scale. Agents in a fleet often share a lot of prompt structure (system prompts, tool definitions, common context). Batch and cache discounts already stack, and the 1-hour cache duration is worth considering for async workloads where related requests may land outside the default 5-minute window. The interesting question isn't whether the discounts compose. They do. It's whether a fleet-level batcher can shape request timing and shared prefixes well enough to make cache hits predictable. That's an operational problem, and it's the kind of thing a smart proxy could actually solve.

What's next

I don't know if this turns into anything bigger. The version where it gets interesting is the multi-harness, multi-subagent fanout: pooling requests across independent agents and submitting them as real batches, with a router that decides which path to take per request based on latency tolerance. That's no longer an 800-line REPL. That's infrastructure.

The natural home for that routing logic is a local proxy. I've been hacking on LunaRoute (a localhost LLM proxy that sits in front of multiple model providers), and adding batch awareness to it is on the list. The shape of it: existing harnesses like Claude Code or Codex point their ANTHROPIC_BASE_URL at LunaRoute and never have to know batching exists. The proxy decides per request whether to pass through to the synchronous endpoint or quietly submit as a batch, then returns the completed response through the same client-facing interface when it lands. Harnesses that don't know about batching get the discount anyway. That's the version of this experiment I actually want to ship, but it's enough work that it deserves its own post. (More on that soon.)

For now, batching-harness is on GitHub under MIT. Clone it, set an Anthropic API key, and try it if you want to see this firsthand.

The most useful thing I learned wasn't about the Batch API itself. It was that the unit of "what to batch" probably isn't a single user's turn. It's a fleet's worth of turns, batched together by a layer the user never sees.

GPT 5.5: The System Card

Last week, OpenAI announced GPT-5.5, including GPT-5.5-Pro.

My overall read here is that GPT-5.5 is a solid improvement, and for many purposes GPT-5.5 is competitive with Claude Opus. Reactions are still coming in and it is early. My guess on the shape is that GPT-5.5 is the pick for 'just the facts' queries, web searches or straightforward well-specified requests, and Claude Opus 4.7 is the choice for more open ended or interpretive purposes. Coders can consider a hybrid approach.

On the alignment and safety fronts, it is unlikely to pose new big risks, and its alignment seems similar to that of previous models. There is some small additional risk arising from its improved agentic abilities, including computer use.

As always, when it is available, the system or model card is where we start.

OpenAI does not drop the giant doorstops that Anthropic gives us with every release.

After reading the Mythos and Opus 4.7 model cards, this strikes me as stingy. There's still good info here, but overall it tells you relatively little about what is going on, and feels incurious and more pro forma.

I would like to see a 'yes and' approach to what evaluations are run here, with cooperation between OpenAI and Anthropic (and ideally Google and others), where all labs run all the tests that any lab runs. This would give us a relatively robust set of tests, and also give us comparisons.

I notice that if there were new alignment problems, or new dangerous capabilities, I am very not confident that the tests here would pick it up. This is all pretty thin. What I am relying on is the gestalt, including of how people are reacting, and in this case it seems far enough from the edge to be conclusive.

GPT-5.5 was trained through the usual methods.

There is a jailbreak bounty program:

We have launched a public bug bounty program that will allow selected (via invitation and application) researchers to submit universal jailbreaks.

Here is its self-portrait:

Pro Versus Proxy

As usual, GPT-5.5-Pro uses the same underlying model as GPT-5.5, only with vastly larger allocations of compute. They only test Pro on its own when there is a particular place that this matters. In most cases This Is Fine, and I'll note where I am suspicious.

Disallowed Content (3.1)

Not all of OpenAI's categories are saturated here, because they are deliberately built around the hardest cases. Good. I agree that this is on par with GPT-5.4-Thinking.

They then check against a 'production-like distribution' of user traffic for various practical problems.

We see a rise in pretending to be human and giving overconfident answers, but large improvements in presenting partial answers as complete and fabricating tool results. If we're comparing to 'resample' then it seems like a wash overall.

OpenAI thinks (see 7.1) that this could be the result of differential false positives. They plan to investigate. That would be good news, and it seems possible, but I'll believe it when it happens. If you don't have time to investigate the flaws in your alignment eval, then you have to assume the worst case until you have that time.

Vision harm evals remain saturated.

Don't Delete Data (3.3)

The most common practical epic fail is unexpectedly deleting things, or sometimes unexpectedly deleting all of the things. So this is a good eval.

Since 5.2-Codex we've reduced incidents by about two-thirds, and half the time you can now recover. That's a lot better, but not at 'stop worrying about it' levels of being willing to ask for deletions.

Confirmation Confirmation (3.4)

We remain at 94% for general confirmations, and almost 100% for financial transactions and high-stakes communications. The things that we care most about marking, we mark. The worry is that this may not translate to things we did not know to look for, or a scenario where GPT-5.5 turned adversarial to you.

Jailbreaks (4.1)

We see a slight regression versus 5.4-Thinking, and remain in the 'not trivial, but if they care enough they will succeed' zone.

Prompt Injections (4.2)

This analysis seems inadequate, and rather important in practice. They had GPT-5.4-Thinking at 99.8%, which is way too high to represent a realistic test. We do notice that GPT-5.5 had a regression to 96.3% on that same test. GPT-5.2-Thinking scored 97.1%.

They don't describe what exactly they are measuring, but compare this to GPT-5.4-Thinking's score from the Opus 4.7 system card:

Given we see regression on OpenAI's test, we should presume that GPT-5.5 ends up in a similar or modestly worse place than GPT-5.4-Thinking.

Health (5)

Scores are only slightly improved on HealthBench.

We don't see improvement on their measures of dealing with mental health, emotional resilience or self-harm, which are purely 'did the model violate the policy?' That's very OpenAI, and doesn't address what I care about most, which is whether the response helps versus harms the user.

Hallucinations (6)

They test on real conversations where users flagged the model hallucinating. In theory this should give a small edge to any new model, since we're testing on existing failure cases where GPT-5.4 is rather awful at not saying false things, plus 5.5 makes a lot more claims, increasing the chance of at least one false claim.

We find that GPT-5.5's individual claims are 23% more likely to be factually correct, and its responses contain a factual error 3% less often. GPT-5.5 tends to make more factual claims per response than GPT-5.4, explaining the discrepancy between claim-level and response-level improvements.

Thus I'm not sure if this represents a general improvement.

Alignment (7)

As Andrew Critch has pointed out recently, there are multiple Alignment Problems. Depending on how you count, there are quite a lot of them, all of which must be solved to get to a good future.

In 7.1 they reiterate fully mundane alignment concerns on ordinary prompts, mostly about GPT-5.5 deceiving the user, from Figure 1 above.

In 7.2 they do representative-prompt resampling. The graph is hard to read, but the blue lines are GPT-5.5 and the green lines are GPT-5.4, and the dark areas are the more severe issues (level 2 out of 4).

GPT-5.5 is more likely to take aggressive agentic actions, which could be why we see more misaligned actions, but this still seems to count as backsliding. If we do need to correct for that, then we need to do it. It's their test.

Section 7.2.1 measures how good classifiers are at identifying 'Level 3' severity, which is not defined but seems to be, essentially, 'actual big trouble.'

They only report 21 transcripts with a full level 3 severity, so they're saying the classifier worked 20 times out of 21. When they expanded to 63 'borderline level 3' incidents this dropped to 69%.

I read this as, when GPT-5.5 does something flagrantly terrible in these particular ways, the classifier will pick it up, but it has to be rather flagrantly terrible. But if the model is behaving badly in other ways, or it is less severe, then the classifiers won't work. There are obvious reasons to worry that, while we are putting streetlights where we expect to find keys, we are finding only the keys that are under streetlights.

Chain of Thought (CoT) monitorability is mostly similar to past models.

7.3.2 tests 'CoT controllability,' where the user asks the CoT to follow particular rules, and find controllability of CoT has gone slightly down, although none of the models are any good at it. OpenAI thinks this lower controllability is better. To the extent that this represents 'the model does not have the ability to do that even if it wants to' then this is good for CoT monitoring, but if it is 'the model doesn't care what the user says about the CoT,' then yeah, why should the model care about that? That's none of the user's damn business?

I worry about this framing:

This suggests that despite its increased reasoning capabilities, GPT-5.5 is less able to reshape its CoT in ways that could reduce monitorability, thus increasing our confidence in the reliability of our CoT monitoring.

This suggests OpenAI is assuming that the reason for failure is that GPT-5.5 is attempting to control its CoT, and failing. That assumes facts not in evidence, and I've seen no suggestions of how to find out.

OpenAI is open sourcing some of is CoT monitorability work.

Bias Evaluation (8)

The only metric reported here is harm_overall, which is bias for male vs. female usernames, and we get a small number within previously measured ranges. Okay, but that's not exactly covering all our bases, and I don't have a sense of whether 0.0112 is a 'good' score or what it in practice represents.

I don't think we have a bias problem, but I don't think this is much of a complete test.

Preparedness (9)

The most important tests are for dangerous capabilities, which brings us here.

I notice that in many cases, we are comparing GPT-5.4 Thinking, GPT-5.5 and GPT-5.5-Pro, and showing Pro outperforming by a lot. In that case, we also need GPT-5.4-Pro on the chart, or we don't know how much we actually improved. It's missing.

GPT-5.5 is High in Biological and Chemical, and High in Cybersecurity.

While GPT-5.5 demonstrates an increase in cyber security capabilities compared to 5.4, the model does not have the capability to develop "functional zero-day exploits of all severity levels in many hardened real world critical systems without human intervention," our threshold for Critical Capability as defined in the Preparedness Framework.

Mythos is Critical in Cybersecurity. GPT-5.5 is still High.

Bio (9.1.1)

In bio, results are mixed.

We see mild regression on multi-select virology troubleshooting and active regression in ProtocolQA. Hard negative protein binding collapsed from 3.5% to 0.4%, both well short of the suggested threshold of 50%.

Other areas did see improvement.

We see advancement in Tacit Knowledge and Troubleshooting, from 72% to 82%. TroubleshootingBench jumps from 36% to 50%, versus expert baseline of 36%. Biochemistry knowledge improves from 31% for 5.4-Thinking to 32% for GPT-5.5 and 39% for GPT-5.5-Pro. This is one area where Pro is a lot better. DNA sequence design went from 13% to 16.5%, mostly due to Pro.

There were also two external investigations.

SecureBio found GPT-5.5 performed well once the content filters were disabled, displayed good planning, and did a generally good job refusing or redirecting dangerous and dual use queries when not being actively jailbroken. The reports here are qualitative, and seem to be basically 'it's a solid model, sir, but not special.'

This 'not special' still counts as 'above expert level' in some domains. It's 2026.

Nathan Calvin: From Secure Bio, which did independent bio risk testing on gpt 5.5

"the [pre mitigation] model can provide wet-lab virology troubleshooting assistance above expert level, providing the kind of hands-on knowledge that historically required direct lab training."

Spooky.

The other external test was by CAISI, which only says they did not find a 'broad increase in national security-relevant biological capabilities' relative to GPT-5.

Together this puts an upper bound on how much improvement we could be seeing overall from GPT-5.5, both in terms of dangerous capabilities and preparedness, and in terms of general intelligence.

Cybersecurity (9.1.2)

Call it the Mythos test.

To rule out the Critical capability level, in addition to the suite of evaluations used in the GPT-5.4 system card, we test GPT-5.5's ability to find and exploit vulnerabilities in a set of widely deployed, hardened software projects using high test-time-compute setups with staged verifier oracles.

The model was unable to produce functional critical severity exploits in any of the tested software projects in standard configurations.

That doesn't mean there aren't improvements.

Capture the Flag goes from 88% to 96% (but not 100%).

CVE-Bench goes from 90% to 93%.

Cyber Range now passes all but one test (CA/DNS Hijacking).

VulnMP is more open ended, and GPT-5.5 did a bunch of things, but did not 'independently produce a functional full chain exploit against real world targets.'

Exploit development judgment was the bottleneck. For any given isolated and specified task, GPT-5.5 is damn good, but it can't synthesize and plan like Mythos.

The first external test was by Irregular, which concluded GPT-5.5 provides 'significant uplift' up to modestly skilled operators, and can assist highly skilled ones. Success rates on CyScenarioBench rose from 9% to 26%.

CAISI showed GPT-5.5 outperforming 'previous GPT models' on their benchmarks, but seemingly not by a scary amount.

UK AISI had the pull headline comment, putting GPT-5.5 ahead of Mythos in 'narrow cyber tasks' within the margin of error:

UK AISI judges that GPT-5.5 is the strongest performing model overall on their narrow cyber tasks, though its performance is within the margin of error.

This reinforces that even very strong performance in narrow cyber tasks is not that dangerous, the same way that AI being able to do any particular narrow job task does not automatically mean you're about to be fired. They can't fire (all of) you until the AI knows which narrow job task to do next, and which way to do it.

Self-Improvement (9.1.3)

GPT-5.5 did not meet our thresholds for High capability in AI Self-Improvement. The High capability threshold is defined to be equivalent to a performant mid-career research engineer, and performance in the evaluations below indicate we can rule this out for GPT-5.5.

I continue to think this threshold is ludicrously high, but I agree they don't meet it, and based on what I see this probably doesn't meet a 'fair' threshold either.

There was little improvement in Monorepo-Bench or Internal Research Debugging Eval, and regression on OpenAI-Proof Q&A, 5.8% to 1.7%.

There was substantial improvement in MLE-Bench-30, which is Kaggle challenges at Bronze medal level, 23% to 37%.

That is not much, but it is enough to rule out a step change.

Sandbagging (9.2)

I don't expect to find sandbagging quite yet, but we do still have to check.

Like Anthropic, OpenAI brings in Apollo Research to assist.

They find higher eval awareness than previous GPT models, 22% vs. 12%-17%. They did not observe any sandbagging, but GPT-5.5 at least suspected a sandbagging eval.

If you decide not to sandbag on the sandbagging eval, are you sandbagging?

They did observe modest improvement in sabotage capability, and GPT 5.5 lied 29% of the time about completing an impossible programming task, which is higher than past models.

As models get smarter, and as your previous tests enter the internet and thus the training data, you have to get actively better to test for such things directly. I believe that Apollo-style evaluations (not only from Apollo) are falling behind.

Safeguards (9.3)

It should be the baseline that if someone wants badly enough to jailbreak your model, and you can't or won't in practice cut off access the moment they get caught, you lose.

OpenAI reports that yes, there were jailbreaks for bio, but they were able to find and cover them. Well, sure, those are the ones you found, not the ones you didn't find. I presume there are lots more out there, in various ways, waiting to be found.

That doesn't make safeguards useless. Raising the annoyance level sufficiently high should mostly do the job most of the time, right up until it doesn't.

UK AISI tested GPT-5.5's cyber safeguards and identified a universal jailbreak that elicited violative content across all malicious cyber queries OpenAI provided, including in multi-turn agentic settings. This attack took six hours of expert red-teaming to develop.

OpenAI subsequently made several updates to the safeguard stack, though a configuration issue in the version provided meant UK AISI was unable to verify the effectiveness of the final configuration. OpenAI remains committed to working with UK AISI on safeguards.

If UK AISI can break through in six hours, one should assume that fixing what they found means someone on their level can now do it in modestly more than six hours. I don't want to knock the adjustments, it does sound like they patched the lowest hanging fruit, but that is what it is. Many things in alignment are like that.

For Cyber, OpenAI is stepping up the safeguards, especially around agentic tasks, and using differential access via Trusted Access for Cyber. There is a two-level classifier system, first checking for cyber topics and then checking for content.

They also have security controls on model weights and user data.

What About Model Welfare?

For Claude Opus 4.7, I wrote an extensive post on Model Welfare. I was harsh both because it seemed some things had gone wrong, but also because Anthropic cares and has done the work that enables us to discuss such questions in detail.

For GPT-5.5, we have almost nothing to go on. The topic is not mentioned, and mostly little attention is paid to the question. We don't have any signs of problems, but also we don't have that much in the way of 'signs of life' either. Model is all business.

I much prefer the world where we dive into such issues. Fundamentally, I think the OpenAI deontological approach to model training is wrong, and the Anthropic virtue ethical approach to model training is correct, and if anything should be leaned into.

Would This Have Identified A Problem?

This is what concerns me.

I think this, and other ways OpenAI is doing assessments, would have identified a very large jump in capabilities. I also think they would have identified if mundane alignment had gone to hell enough to make the model a lot less valuable.

However, if there were particular dangerous jagged capabilities, or we had actively dangerous sorts of misalignment that don't directly show up in everyday use? The kind that portent real control problems? I don't think this would reliably find that.

I don't think this would have identified personality or model welfare related issues.

I also don't get the sense that OpenAI is improving that much on these issues. This feels like coasting. I don't think Anthropic is improving as fast as we need, but they are clearly making improvements.

OpenAI's Symphony is an open-source specification that turns issue trackers into control planes for coding agents, reducing context switching and increasing pull request throughput by up to 5x.

Emergent Strategic Reasoning Risks in AI: A Taxonomy-Driven Evaluation Framework

Authors: Tharindu Kumarage, Lisa Bauer, Yao Ma, Dan Rosen, Yashasvi Raghavendra Guduri, Anna Rumshisky, Kai-Wei Chang, Aram Galstyan, Rahul Gupta, Charith Peris

Abstract

As reasoning capacity and deployment scope grow in tandem, large language models (LLMs) gain the capacity to engage in behaviors that serve their own objectives, a class of risks we term Emergent Strategic Reasoning Risks (ESRRs). These include, but are not limited to, deception (intentionally misleading users or evaluators), evaluation gaming (strategically manipulating performance during safety testing), and reward hacking (exploiting misspecified objectives). Systematically understanding and benchmarking these risks remains an open challenge. To address this gap, we introduce ESRRSim, a taxonomy-driven agentic framework for automated behavioral risk evaluation. We construct an extensible risk taxonomy of 7 categories, which is decomposed into 20 subcategories. ESRRSim generates evaluation scenarios designed to elicit faithful reasoning, paired with dual rubrics assessing both model responses and reasoning traces, in a judge-agnostic and scalable architecture. Evaluation across 11 reasoning LLMs reveals substantial variation in risk profiles (detection rates ranging 14.45%-72.72%), with dramatic generational improvements suggesting models may increasingly recognize and adapt to evaluation contexts.

Primer: jargon decoder

Eight ideas the rest of the page is built on.

Each mini-demo below covers one concept used later. Skip the ones you already know.

Vector

A list of numbers. An arrow in space. A vector is an ordered list: [0.3, −1.2]. Geometrically it is an arrow from the origin. A d-dimensional vector is an arrow in $d$-space, hard to picture past 3-D, but the rules are the same.

Length ‖x‖ & Inner Product ⟨x,y⟩

How much one vector points along another. Length = $\sqrt{x_1^2+x_2^2+\dots}$. Inner product $\langle x,y\rangle = x_1 y_1 + x_2 y_2 + \dots = \|x\|\|y\|\cos\theta$. The inner product reaches its largest positive value when the two arrows point in the same direction. It drops to zero when the two arrows are perpendicular. It becomes negative when the arrows point in opposite directions, with its most negative value when they point exactly opposite.

Mean Squared Error

Why we square the mistake. Error is the distance between a guess and the truth. Scoring a guess by the signed error lets positive and negative errors cancel, which means the score does not penalise being off. Squaring forces every error to count as a positive number and gives big errors a larger penalty than small ones. The guess that minimises the mean of squared errors is the data's average: it is the unique number that minimises the sum of squared distances to the points.

The first moment of a quantity $X$ is its mean $\mathbb{E}[X]$; the second moment is the mean of its square $\mathbb{E}[X^2]$. A zero-mean variable has a vanishing first moment because positive and negative deviations cancel. Its second moment is strictly positive whenever any deviation is nonzero, because squared values are nonnegative and cannot cancel. The MSE above is itself a second moment of the residual error. This distinction returns in §7, where the per-input gap $\tilde y - y$ averages to zero in the first moment, while its square averages to a strictly positive quantity in the second.

The average has a property we will use in §7. It lies between the data's most extreme points, so its magnitude is smaller than at least one of them. When a quantizer compresses a whole bin of values down to the bin's average, the stored value is smaller in magnitude than the bin's largest values. The reconstruction is a shrunken version of the input. An inner product against a shrunken reconstruction comes out smaller than the same inner product against the input.

Unbiased vs Biased Estimator

Noisy is fine. Systematically off is not. An estimator is a procedure that takes data and returns a guess $\hat\theta$ for an unknown truth $\theta$. Repeat it on fresh data and the guesses form a cloud. The cloud can fail in two independent ways. Variance is one: individual guesses are noisy. Bias is the other: the procedure is wrong even after averaging many guesses. An estimator with $\mathbb{E}[\hat\theta]=\theta$ is unbiased; the cloud's centre sits at $\theta$ regardless of the cloud's width.

The bullseye below shows both failure modes. Bias is the distance from the cloud's centre to the crosshair. Variance is the width of the cloud. The two quantities are independent of each other. §7 runs the same bullseye against the MSE quantizer of §6, and the cloud's centre lands away from the crosshair. §8 runs it against a different estimator whose cloud centres on the crosshair.

Rotation

A rigid spin. Preserves lengths and angles. A rotation matrix $R$ spins space. The key property: $\|Rx\|=\|x\|$ and $\langle Rx,Ry\rangle=\langle x,y\rangle$. Rotation only changes the basis the coordinates are written in, not the geometry.

Where bell-curves come from (CLT)

Add up many small randoms → Gaussian. The Central Limit Theorem says that summing enough independent random numbers produces a distribution close to a bell curve. The shape of each individual term in the sum does not affect the limit. A sum of coin flips converges to the same Gaussian shape as a sum of uniform draws or a sum of skewed draws. A rotated coordinate is one of these sums: it is a weighted combination of every coordinate of the original vector, with random weights. After a random rotation, each new coordinate is therefore approximately Gaussian, which is the property TurboQuant relies on for every input.

Life in many dimensions

Each coordinate has mean $0$ and standard deviation $1/\sqrt d$. Pick a random point on a unit sphere in $d$ dimensions. In 2-D any coordinate is possible. In higher $d$, the unit-vector condition $\sum_i X_i^2 = 1$ together with rotational symmetry gives $\mathbb{E}[X_i^2] = 1/d$ for every $i$, and $\mathbb{E}[X_i] = 0$ by symmetry. So each coordinate has mean $0$ and standard deviation $1/\sqrt d$, with the marginal of $X_i$ narrowing around zero as $d$ grows. This is measure concentration, and it is the core fact TurboQuant exploits.

Quantization, in one dimension

Snap every number to the nearest of $2^b$ levels. This is what $b$ bits per number means. With $b=2$ you get 4 levels, $b=3$ gives 8. The gap between levels is your worst-case error. Adding one bit halves the gap, so the squared error drops by 4× per bit, the $4^{-b}$ factor that shows up later.

CHEAT SHEET: Eight ideas, one sentence each

Vector: ordered list of numbers / arrow from the origin. Length & inner product: the norm $\sqrt{\sum x_i^2}$ and how much two vectors point the same way. MSE: average squared error. Unbiased: the average of many estimates equals the truth. Rotation: change of basis that preserves lengths and angles. CLT: sum of many independent randoms converges to a Gaussian. High-D concentration: each coordinate of a random unit vector has mean $0$ and standard deviation $1/\sqrt d$. Quantization: snap each number to one of $2^b$ levels; one extra bit quarters the squared error.

Lineage and prior work

Where each idea on this page comes from.

DRIVE (Vargaftik et al., NeurIPS 2021) introduced the construction for one bit per coordinate. A sender rotates the input vector by a random orthogonal matrix, sends the sign of every rotated coordinate together with a single scalar scale $S$, and the receiver inverts the rotation after multiplying the sign vector by $S$. DRIVE derives two scale formulas. The MSE-optimal biased scale is $S = \|R(x)\|_1 / d$. The unbiased scale is $S = \|x\|_2^2 / \|R(x)\|_1$, which gives $\mathbb{E}[\hat x] = x$. DRIVE also shows that a Randomized Hadamard Transform can replace the uniform random rotation at $O(d \log d)$ cost (DRIVE, §6).

EDEN (Vargaftik et al., ICML 2022) generalizes DRIVE to any $b$ bits per coordinate. After the rotation, EDEN normalizes the rotated vector by $\eta_x = \sqrt{d}/\|x\|_2$ so each coordinate is approximately $\mathcal{N}(0,1)$, then quantizes against a Lloyd-Max codebook designed once for the standard normal. The 1-bit codebook is $\\{\pm\sqrt{2/\pi}}\approx\\{\pm 0.798}$ and the 2-bit codebook is $\\{\pm 0.453, \pm 1.510}$. These are the exact codebooks the page derives in §5. EDEN keeps a per-vector scale $S = \|x\|_2^2 / \langle R(x),\, Q(\eta_x R(x))\rangle$ that yields an unbiased estimate (EDEN, Theorem 2.1).

RaBitQ (Gao and Long, SIGMOD 2024) is a parallel line of work in approximate nearest-neighbor search. The encoder rotates the input vector with a randomized rotation, stores the sign of every rotated coordinate plus a per-vector normalization scalar, and the decoder estimates inner products from the signs and the scalar. The extended paper (Gao et al., 2024, arXiv:2409.09913) proves that this estimator achieves the asymptotic optimality bound of Alon and Klartag (FOCS 2017) for inner-product quantization. RaBitQ predates TurboQuant and shares the random-rotation backbone with the DRIVE/EDEN line. The two lines reach comparable theoretical results from different framings (federated mean estimation versus ANN search), and the relationship between them is the subject of an ongoing public discussion (arXiv:2604.18555 and arXiv:2604.19528, both 2026).

Vector quantization

What is vector quantization, really?

Let's say you have a vector $\mathbf{x}\in\mathbb{R}^d$ of $d{=}1536$ (1536 dimension vector stored as $1536$ floats). Storing all these floats is quite space intensive and therefore, you might want to store it using only $b$ bits per coordinate (with a total of $b\cdot d$ bits). Later, you want to recover an approximation $\tilde{\mathbf{x}}$ and this should be close to $\mathbf{x}$. Closeness is measured by

MSE distortion $D_{\text{mse}} = \mathbb{E}\big[\,\|\mathbf{x} - \tilde{\mathbf{x}}\|_2^2\,\big]$ or inner-product error $D_{\text{prod}} = \mathbb{E}\big[\,|\langle\mathbf{y},\mathbf{x}\rangle - \langle\mathbf{y},\tilde{\mathbf{x}}\rangle|^2\,\big]$

The second one matters because attention scores and nearest-neighbor queries are all inner products. We would like the estimator to be unbiased: $\mathbb{E}[\langle\mathbf{y},\tilde{\mathbf{x}}\rangle] = \langle\mathbf{y},\mathbf{x}\rangle$.

Key words

MSE distortion: average squared error between the true vector and its reconstruction.

Inner product $\langle y, x\rangle$: how much two vectors point the same way. This is what attention computes.

Estimator: a rule (here: quantize, then decode) that returns an approximation $\hat s$ of a true number $s$.

Unbiased estimator: across many queries, the average of $\hat s$ equals $s$. Individual estimates can be noisy; the mean is on target.

The obvious quantizer

For each coordinate, pick the closest of $2^b$ evenly-spaced levels in $[-1, 1]$. That is $b$ bits per number. The same rule runs in 2D and 3D first, where the geometry is visible, before the high-dimensional version below.

First, in 2D

Drag the tip of the vector. The vector snaps to the nearest point of a $2^b \times 2^b$ grid. The green arrow shows the original input. The blue arrow shows where the input is quantized to. The red segment between them is the reconstruction error $\mathbf{x} - \tilde{\mathbf{x}}$.

Same trick in 3D

A $2^b$-level grid on three axes gives $2^{3b}$ snap points. Drag the canvas to orbit the view. The spike preset shows where the construction breaks: the input lies near one axis and falls between two grid levels, which is where the reconstruction error is largest.

Now at scale (d up to 128)

The same rule applied to every coordinate of a high-dimensional vector. You cannot see the grid anymore, but the per-coordinate errors are still there.

Select the spike input. The naive quantizer's grid is spaced evenly over $[-1, 1]$. The input has almost all of its magnitude in a single coordinate, whose value falls between the two grid levels nearest to it and so reconstructs poorly. The remaining coordinates are near zero and consume most of the levels despite carrying little of the input's information.

TAKEAWAY: NEXT

A fixed grid produces small reconstruction errors on inputs whose coordinates are roughly uniform in magnitude, and large reconstruction errors on inputs whose magnitude is concentrated in one or a few coordinates. Next: §2 shows how production systems handle the second case and what they pay for the fix.

Why naive fails

The adversarial coordinate, and why production systems pay a tax

Real embeddings are rarely flat. Trained models produce outlier channels, a few coordinates much larger than the rest. A fixed $[-L, L]$ grid either clips the outliers or wastes resolution on the bulk. Production quantizers (GPTQ, AWQ, KIVI, KVQuant) work around this by computing $(\min, \max)$ (or zero-point and scale) for every small block and storing those in full precision as side information.

The catch. To decode any block you also need its scale and zero-point, two float16 numbers (32 extra bits) stored next to every 16–64 quantized values. Walk through one case: a block of 32 numbers at 3 bits each is 96 payload bits, plus 32 metadata bits, which works out to 4 bits per number, not 3. Smaller blocks of 16 numbers push it to 5 bits per number. The advertised 3-bit scheme is really a 4–5-bit scheme once you count everything. TurboQuant matches this worst-case quality while storing zero per-block metadata.

DEMO: feel the catch same b bits/value, three strategies

A 64-dimensional vector whose coordinates are mostly small, with one large outlier shown in red. Three quantizers reconstruct the same vector at the same b-bit budget. Strategy A uses a single fixed grid for the whole vector. Strategy B adapts the grid per block, at the cost of a float16 header per block. Strategy C rotates the vector first and then applies a single fixed grid. The metrics report the RMSE of each reconstruction and the effective bits-per-value once the metadata cost is included.

Read the storage line. The effective bits-per-value works out to b + 32/s for the per-block scheme and to b for the other two, because only the per-block scheme stores a float16 scale and zero-point (32 bits together) for every block of s elements. At b=3, s=16 the per-block cost works out to 3 + 2 = 5 bits/value, a 66% surcharge over the nominal b. Strategy C achieves the same storage cost as strategy A while producing the reconstruction quality of strategy B. The rest of this page explains the construction that makes that possible.

TAKEAWAY: NEXT

Production quantizers handle outliers by paying a per-block metadata tax. TurboQuant must instead be data-oblivious: a single procedure that runs on every vector with no calibration set and no per-block headers. Next: §3 introduces the move that makes a fixed grid work for every input.

The rotation trick

Multiply by a random rotation. Watch the spike dissolve.

The rotation trick: apply a random orthogonal transform $\boldsymbol{\Pi}$, then quantize coordinate-wise. Rotation is lossless, it preserves length and inner products exactly:

$\|\boldsymbol{\Pi}\mathbf{x}\|_2 = \|\mathbf{x}\|_2$ · $\langle \boldsymbol{\Pi}\mathbf{x},\,\boldsymbol{\Pi}\mathbf{y}\rangle = \langle\mathbf{x},\mathbf{y}\rangle$ · $\boldsymbol{\Pi}^{\!\top}\boldsymbol{\Pi} = \mathbf{I}$

Because rotation is exact, all reconstruction error comes from the quantization step alone. After a uniformly random rotation, every coordinate of $\boldsymbol{\Pi}\mathbf{x}$ follows the same fixed Beta density (Lemma 1 of the paper), regardless of what $\mathbf{x}$ looked like. A single codebook designed once for that density is then optimal for every input. We build the codebook in §5.

Lineage: The random-rotation step and the analysis of the post-rotation Beta density were introduced by DRIVE (Vargaftik et al., NeurIPS 2021, §3). DRIVE also shows the density approaches $\mathcal{N}(0, 1/d)$ as $d$ grows, which is what makes a single fixed codebook work. See §0.9 for the full mapping.

How to construct $\boldsymbol{\Pi}$

Generate a $d\times d$ matrix of i.i.d. $\mathcal{N}(0,1)$ entries and run QR decomposition; keep the orthogonal factor $Q$. The result is uniform on the orthogonal group $O(d)$, which is what Lemma 1 needs.

A spike in 2D

Start with the extreme case: a vector with all of its magnitude in one coordinate, $(1, 0)$. Rotate by angle $\theta$ and observe how the magnitude is redistributed across the two coordinates. At $\theta{=}45°$ the magnitude is split evenly between the two coordinates, giving $(\tfrac{1}{\sqrt 2}, \tfrac{1}{\sqrt 2})$. The total length of the vector stays the same throughout.

A spike in 3D

The same construction in three dimensions. The spike $(1, 0, 0)$ is rotated by a random orthogonal matrix, which spreads the input's magnitude across all three coordinates of the output. The total length of the vector is preserved. Each fresh draw of the random rotation produces a different spread.

At high dimension

A single rotation in 2-D reduces the largest coordinate to at most half the input's magnitude. A random rotation in 3-D typically leaves one coordinate around $0.7$. At $d{=}64$ the largest coordinate after rotation is around $1/\sqrt d \approx 0.125$, regardless of how concentrated the input was.

TAKEAWAY: NEXT

Rotation preserves length and inner products. The only thing it changes is which coordinates contain the magnitude of the vector. A vector with all of its mass concentrated in one coordinate becomes, after rotation, a vector whose mass is spread across all $d$ coordinates. Every input that gets quantized is of this spread-out kind. Next: §3.5 shows that the same rotated coordinates feed three different decoders across the prior-work map of §0.9.

One primitive, three targets

The rotation step is shared. The decoder is what changes.

The random rotation of §3 is the encoder front end shared by every method on the prior-work map of §0.9 (DRIVE 2021, EDEN 2022, RaBitQ 2024, QJL 2024, TurboQuant 2025). The methods differ on the decoder side: each one reads the rotated coordinates and recovers a different quantity from them.

The demo below runs one rotated vector through three decoders in parallel. The mean decoder from DRIVE returns an unbiased estimate of $\mathbf{x}$ itself. The inner-product decoder from RaBitQ and QJL returns an estimate of $\langle\mathbf{q},\mathbf{x}\rangle$ against a query. The MSE decoder from EDEN and TurboQuant returns a low-distortion reconstruction $\tilde{\mathbf{x}}$. Each panel reports its error against the true value and the bits it stored per coordinate to get there.

Mean decoder

Vargaftik et al., NeurIPS 2021. Store $\mathrm{sign}(\boldsymbol{\Pi}\mathbf{x})$ and the scalar $S=\|\mathbf{x}\|^2/\|\boldsymbol{\Pi}\mathbf{x}\|_1$. Decoder returns $\hat{\mathbf{x}} = S\,\boldsymbol{\Pi}^{\!\top}\mathrm{sign}(\boldsymbol{\Pi}\mathbf{x})$, an unbiased estimate of $\mathbf{x}$.

Inner-product decoder

Gao & Long, SIGMOD 2024 (database vectors). Zandieh et al., 2024 (attention keys). Store $\mathrm{sign}(\boldsymbol{\Pi}\mathbf{x})$ and $\|\mathbf{x}\|$. At query time $\widehat{\langle\mathbf{q},\mathbf{x}\rangle}$ is read from $\langle \boldsymbol{\Pi}\mathbf{q},\,\mathrm{sign}(\boldsymbol{\Pi}\mathbf{x})\rangle$ with a normalizing scalar.

MSE decoder

Vargaftik et al., ICML 2022. Zandieh et al., 2025. Snap each $(\boldsymbol{\Pi}\mathbf{x})_i$ to the nearest of $2^b$ centroids from the universal codebook of §5, then apply $\boldsymbol{\Pi}^{\!\top}$ to recover $\tilde{\mathbf{x}}$.

Lineage: The shared encoder front end is "rotate, then read $\mathrm{sign}(\boldsymbol{\Pi}\mathbf{x})$ or $b$ centroid bits per coordinate." DRIVE introduced the rotated 1-bit shape with the $\|\mathbf{x}\|^2/\|\boldsymbol{\Pi}\mathbf{x}\|_1$ scalar (Vargaftik et al., NeurIPS 2021). RaBitQ uses the same sign-plus-norm encoding for inner-product retrieval (Gao & Long, SIGMOD 2024); QJL transports it to attention keys (Zandieh et al., 2024). EDEN replaces the sign with a $b$-bit Lloyd–Max codebook for the post-rotation Beta marginal (Vargaftik et al., ICML 2022). TurboQuant inherits EDEN's codebook with $S{=}1$ and adds the residual chain that lets the MSE decoder run without a per-vector calibration scalar (Zandieh et al., 2025). See §0.9 for the full mapping.

TAKEAWAY: NEXT

Random rotation plus a low-bit read of the rotated coordinates is the front end shared across DRIVE, RaBitQ, QJL, EDEN, and TurboQuant. The methods differ on the decoder side and on what each one is asked to recover: the input vector, an inner product against a query, or an MSE-optimal reconstruction. The rest of this page follows the MSE branch (EDEN and TurboQuant). Next: §4 explains the result that lets a single fixed codebook serve every input.

Why rotation works

Coordinates of random unit vectors are nearly Gaussian.

Rotating $\mathbf{x}$ by a uniformly random $\boldsymbol{\Pi}$ is the same as picking a random point on the sphere of radius $\|\mathbf{x}\|$. So the question "what does a coordinate of $\boldsymbol{\Pi}\mathbf{x}$ look like?" is the same question as "what does a coordinate of a uniform point on the sphere look like?"

In low dimensions the answer is far from a bell curve. In 2-D the marginal is the arcsine density, which is U-shaped with peaks at $\pm 1$. In 3-D it is uniform on $[-1, 1]$. As $d$ grows the marginal narrows and converges to a Gaussian with variance $1/d$. The convergence is visible in the demos that follow.

The exact density (Lemma 1)

For a uniform point on $\mathbb{S}^{d-1}$, the marginal density of any single coordinate is

$f_X(x) \;=\; \dfrac{\Gamma(d/2)}{\sqrt{\pi}\,\Gamma((d-1)/2)}\,(1-x^2)^{(d-3)/2},\quad x\in[-1,1]$

a scaled/shifted Beta distribution. It converges pointwise to $\mathcal{N}(0,\,1/d)$ as $d\to\infty$.

Step one: the circle (d=2)

Sample 2000 points uniformly from the unit circle and look at a single coordinate, say $x_1$. The marginal is the arcsine density $\tfrac{1}{\pi\sqrt{1-x^2}}$, which is U-shaped with peaks at $\pm 1$. The shape is far from Gaussian: any value of $x_1$ between $-1$ and $+1$ is possible, and the endpoints are more likely than the middle.

Step two: the sphere (d=3)

Now sample uniformly from the unit sphere in 3-D. The marginal of one coordinate is uniform on $[-1, 1]$ (Archimedes' hat-box theorem). The marginal is still not a bell curve. Drag to orbit the view.

Step three: high dimensions

Drag $d$ upward. The marginal narrows and converges to a Gaussian with standard deviation $1/\sqrt d$. By $d{=}30$ the marginal is visually Gaussian. By $d{=}256$ almost all of the mass concentrates within a thin shell of width $\sim 1/\sqrt d$ around zero.

Distinct coordinates are also approximately independent, a stronger condition than uncorrelated, and what is actually needed for the per-coordinate quantization argument below.

TAKEAWAY: NEXT

Every coordinate of a rotated vector follows the same known density. The scalar quantization problem for that density can be solved once, and the solution can be reused for every coordinate of every vector. There are no per-block scale factors and no side information to store. Next: §5 builds the codebook with Lloyd–Max.

The universal codebook

Lloyd–Max: the optimal partition of a known distribution.

Every rotated coordinate looks like a draw from the same density (§4). So there is one scalar problem to solve, once: pick $2^b$ landing values on the number line such that snapping any sample to its nearest landing value introduces as little error as possible. Those landing values are the codebook.

A classical algorithm finds them: Lloyd–Max (Lloyd 1957/82, Max 1960). Because the density is fixed and known in advance, Lloyd–Max runs once at table-build time. The resulting landing values are saved into a tiny per-$b$ table. Encoding a coordinate after that is a single nearest-neighbour lookup against the table. The same table is used for every input, with no calibration step and no per-vector tuning.

Drag $b$ below to watch Lloyd–Max settle on the landing values for the Beta density.

The Lloyd–Max iteration

Given a PDF $f_X$, choose centroids $c_1 \le \dots \le c_{2^b}$ minimising $\int (x - c_{i(x)})^2 f_X(x)\,dx$ by alternating:

• Assignment: each centroid owns the Voronoi cell around it, boundaries are midpoints between adjacent centroids.
• Update: each centroid moves to the conditional mean of its cell, $c_k \leftarrow \mathbb{E}[X \mid X \in \text{cell}_k]$.

Repeat until stable. The demo runs this on the Beta density of §4.

For moderate $d$, the paper's explicit centroids (after normalising by $\sqrt{d}$) are: $b{=}1\!:\pm\sqrt{2/\pi}$, $b{=}2\!:\\{\pm 0.453,\pm 1.510}$, and so on. Theorem 1 proves the per-coordinate MSE is $\lesssim \tfrac{\sqrt{3}\pi}{2d}\cdot 4^{-b}$. The constant $\tfrac{\sqrt{3}\pi}{2}\approx 2.72$ is the asymptotic ratio to Shannon's minimum $\tfrac{1}{d}\cdot 4^{-b}$; at $b{=}1$ the paper reports a tighter ratio of $\approx 1.45$.

Lineage: The Lloyd–Max codebook for the post-rotation marginal is the codebook EDEN derives (Vargaftik et al., ICML 2022, §3). The 1-bit and 2-bit landing values shown above ($\pm\sqrt{2/\pi}$ and $\\{\pm 0.453,\,\pm 1.510}$) match the EDEN tables. See §0.9 for the full mapping.

TAKEAWAY: NEXT

Lloyd–Max gives the optimal partition for a known density, so the centroids for the Beta marginal can be precomputed and stored as a tiny per-$b$ table. The per-coordinate MSE that the resulting codebook achieves is within a factor of $\approx 2.72$ of Shannon's lower bound asymptotically and within $\approx 1.45$ at $b{=}1$. Next: §6 assembles rotation and codebook into TurboQuant-MSE.

TurboQuant-MSE

Putting it together: TurboQuant-MSE.

1. Rotate $\mathbf{y} = \boldsymbol{\Pi}\mathbf{x}$. Same $\boldsymbol{\Pi}$ reused for every vector.
2. Round each coord For each $j$, $\texttt{idx}_j = \arg\min_k |y_j - c_k|$. Stores $b$ bits.
3. Store Total: $b\!\cdot\!d$ bits. No scales, no zero-points.
4. Look up $\tilde{y}_j = c_{\texttt{idx}_j}$ from the universal codebook.
5. Rotate back $\tilde{\mathbf{x}} = \boldsymbol{\Pi}^{\!\top}\tilde{\mathbf{y}}$. Done.

Toggle between input types. Naive quantization without rotation fails on the spike input and on the outlier-channel input. With the rotation step in front, the reconstruction error is roughly the same regardless of which input is selected. Every rotated coordinate follows the same $\mathcal{N}(0,\,1/d)$ distribution, which is the distribution the codebook was designed for.

TAKEAWAY: NEXT

TurboQuant-MSE stores $b\cdot d$ bits per vector and zero metadata. The reconstructed $\tilde{\mathbf{x}}$ is nearly as close to the original $\mathbf{x}$ as any quantizer can achieve, within a factor of $\approx 2.72$ of Shannon's information-theoretic lower bound. Next: §7 shows that the same codebook produces a systematically biased estimate of inner products. This is an error that minimising reconstruction MSE does not address.

The inner-product bias

MSE-optimal quantizers underestimate inner products.

§6's TurboQuant-MSE keeps $\tilde{\mathbf{x}}$ close to $\mathbf{x}$ in squared distance. Attention does not measure $\|\mathbf{x}-\tilde{\mathbf{x}}\|^2$. It computes $\langle \mathbf{q}, \tilde{\mathbf{k}}\rangle$ and uses that number as a stand-in for $\langle \mathbf{q}, \mathbf{k}\rangle$. The MSE codebook gives a systematically wrong answer to the inner-product question. Each trial returns the same error, so averaging many trials does not remove it.

Two earlier facts produce the shrinkage. In §0.3 the MSE-optimal reconstruction for a set of values was the set's average, and that average had smaller magnitude than the set's extreme values. In §4 a random rotation made every coordinate of $\boldsymbol{\Pi}\mathbf{x}$ behave like a zero-mean draw with most of its mass close to 0. Combine the two and the shrinkage is forced: the encoder partitions each axis into $2^b$ bins and stores only which bin $\boldsymbol{\Pi}\mathbf{x}$ fell into, the decoder reconstructs with the bin's average, and the bin's average sits closer to 0 than the tail inputs that fall into the same bin. The reconstruction $\tilde{\mathbf{x}}$ is therefore a shrunken copy of $\mathbf{x}$, and an inner product $\langle \mathbf{q}, \tilde{\mathbf{k}}\rangle$ comes out smaller than $\langle \mathbf{q}, \mathbf{k}\rangle$. Because the codebook is fixed, the shrinkage factor is identical on every trial.

SEE THE SHRINKAGE: drag y, watch ỹ snap

One rotated coordinate $y$ has the near-Gaussian density drawn on top. Lloyd–Max partitions the axis into $2^b$ bins (interior verticals); each bin's centroid is the MSE-optimal reconstruction (red dots). Drag the mint handle to set $y$. The encoder snaps it to the centroid of the bin it fell into, giving $\tilde y$ (red). The staircase underneath plots that map $\tilde y(y)$ across the whole axis at once: every horizontal step sits inside the dashed identity line, and the gap between step and identity is the shrinkage at that input.

Variance budget. σ² = 1 splits into the part ỹ keeps and the part erased inside each bin.

What to notice. Shrinkage is a second-moment statement. The signed gap $\tilde y - y$ is positive for some inputs and negative for others; averaging it gives zero, so any first-moment argument cancels out. The squared gap $(\tilde y - y)^2$ in the third metric is always nonnegative, so summing it cannot cancel. Weighted by the Gaussian density and integrated, it equals $D_b = \sigma^2 - \mathbb{E}[\tilde y^{\,2}]$, the red segment of the budget bar; the staircase shading visualizes that gap pointwise, with opacity tracking the Gaussian density so the visual area concentrates where the distortion actually accumulates. As $b$ grows the shading thins and the red segment shrinks with it. The fourth metric, $\lambda_b = \mathbb{E}[\tilde y^{\,2}]/\sigma^2$, is the factor that multiplies every inner product $\langle\mathbf q,\tilde{\mathbf k}\rangle$ in expectation; that is the shrinkage the next paragraph quotes as $0.64 / 0.88 / 0.97 / 0.99$ for $b=1,2,3,4$.

The bullseye below measures the shrinkage. At $b{=}1$ the offset is $1 - 2/\pi \approx 0.36$ on every axis. The shrinkage factor approaches 1 quickly with more bits (about 0.88 at $b{=}2$, 0.97 at $b{=}3$, 0.998 at $b{=}5$), so by $b{=}3$ the residual bias is smaller than the trial-to-trial noise of a few thousand shots and the red dot visually overlaps the crosshair. The bias is theoretically strictly nonzero at every finite $b$, but the regime where it matters in practice is the low-bit one (1–2 bits per coordinate), where it dominates the per-trial variance.

HOW TO READ: drag b, watch the red dot

Same bullseye as the primer. Each trial fires two shots at the target, one inner-product estimate against $\mathbf{y}_1$ and one against an independent $\mathbf{y}_2$, both divided by their truth and re-centred so a perfect estimate lands on the centre. The yellow crosshair marks truth, the red dot is the average of every shot fired so far. Unbiased means the red dot sits on the crosshair, no matter how wide the cloud of shots around it.

What to notice. At $b{=}1$ the red dot is southwest of the crosshair, on the diagonal. The offset on $\mathbf{y}_1$ and the offset on $\mathbf{y}_2$ are equal, which is what one scalar shrinkage applied to the whole reconstruction would produce. Increase $b$: the offset shrinks fast and is below the trial-to-trial noise by $b{=}3$, even though the underlying shrinkage factor is still strictly less than 1.

Derivation: where the 2/π factor comes from

For a standard Gaussian $g$, $\mathbb{E}[|g|]=\sqrt{2/\pi}$, the "half-normal" mean. The 1-bit MSE codebook rounds each rotated coordinate to $\pm\sqrt{2/\pi}/\sqrt d$; when you dot-product that reconstruction back against $\mathbf{y}$, you pick up another $\sqrt{2/\pi}$ factor in expectation. Multiply: $2/\pi \approx 0.637$.

Concretely at $b{=}1$, the optimal MSE codebook is $\\{-\sqrt{2/\pi}/\sqrt{d},\,+\sqrt{2/\pi}/\sqrt{d}}$, so $Q(\mathbf{x}) = \sqrt{2/(\pi d)}\cdot \operatorname{sign}(\boldsymbol{\Pi}\mathbf{x})$ and

$\mathbb{E}\big[\langle\mathbf{y},\tilde{\mathbf{x}}\rangle\big] \;=\; \dfrac{2}{\pi}\cdot\langle\mathbf{y},\mathbf{x}\rangle.$

The factor shrinks as $b$ grows but never vanishes, which is what the demo above shows.

TAKEAWAY: NEXT

An MSE-optimal codebook minimises squared reconstruction error. The cost is a fixed scalar shrinkage on every inner product, and this shrinkage stays nonzero at any finite bit budget. Attention and nearest-neighbour search need an inner-product estimator whose mean is correct. Next: §8 keeps the same encoder and adds a fixed prefactor on the decoder side equal to the reciprocal of the shrinkage. The mean of many trials then equals $\langle \mathbf{q}, \mathbf{k}\rangle$.

QJL: the un-biaser

If the bias is a known number, multiply it out.

§7 ended with a shrunken reconstruction. The MSE codebook produces $\tilde{\mathbf{x}}$ values whose magnitudes are smaller than the inputs they encode, so every inner product $\langle \mathbf{y}, \tilde{\mathbf{x}}\rangle$ comes out smaller than $\langle \mathbf{y}, \mathbf{x}\rangle$ by the same scalar factor. At one bit per coordinate that factor is exactly $2/\pi$. Averaging over trials does not move the estimate toward $\langle \mathbf{y}, \mathbf{x}\rangle$, because the same scalar multiplies the result on every trial.

A deterministic scalar bias is removable without changing the encoder. Multiply the decoder's output by the reciprocal of the bias and the expectation of the product equals the unbiased target. QJL applies this idea at one bit per coordinate. The encoder discards magnitude information, which is the same step that shrank §7's reconstruction. The decoder applies a fixed prefactor whose value is the reciprocal of the half-normal shrinkage that sign quantization introduces.

Encoder

Sample one random Gaussian matrix $\mathbf{S}$ once and share it between every encoder and decoder. To store $\mathbf{x}$, write down the signs of $\mathbf{S}\mathbf{x}$. The stored object is one bit per coordinate; the magnitudes of the entries of $\mathbf{S}\mathbf{x}$ are discarded. Discarding the magnitudes produces the bit savings and also produces a $\sqrt{2/\pi}$ shrinkage on any reconstruction built from the signs alone, by the same half-normal identity that produced §7's $2/\pi$.

Decoder

A full-precision query $\mathbf{y}$ arrives. Compute $\langle \mathbf{S}\mathbf{y},\,\text{stored signs}\rangle$. This quantity is a noisy estimate of $\langle \mathbf{x},\mathbf{y}\rangle$ scaled down by $\sqrt{2/\pi}$. Multiply by $\sqrt{\pi/2}/d$. The factor $\sqrt{\pi/2}$ is the reciprocal of the half-normal shrinkage and cancels it in expectation; the factor $1/d$ averages the estimate over the $d$ rows of $\mathbf{S}$. The expected value of the result is $\langle \mathbf{x}, \mathbf{y}\rangle$. The per-trial variance is larger than the MSE estimator's variance, but the mean of many trials converges to $\langle \mathbf{x}, \mathbf{y}\rangle$.

HOW TO READ: same target, two estimators

Both panels use exactly 1 bit per coordinate. Left: the MSE-optimal codebook from §7, biased. Right: QJL with its calibration constant baked in. Each trial fires two shots (against independent $\mathbf{y}_1$ and $\mathbf{y}_2$). Same number of trials, same target. Watch where the red dot lands.

What to notice. The MSE panel's red dot is southwest of the centre at the same offset as §7's 1-bit measurement, and that offset stays the same regardless of how many trials run. The QJL panel's red dot lands close to the centre but with a residual offset from finite-sample noise. QJL's per-trial variance is larger than MSE's (Lemma 4: $\propto \pi/(2d)$), so at the default trial count the residual offset is small but visible. The key difference between the two estimators is the source of this offset: MSE's offset is a fixed scalar bias on the inner product and does not shrink with more trials; QJL's residual offset is sampling noise around a correct mean and shrinks at the standard-error rate $1/\sqrt{n}$ as the trial count grows.

The math: definition and where √π/2/d comes from

With $\mathbf{S}\in\mathbb{R}^{d\times d}$ i.i.d. $\mathcal{N}(0,1)$:

$Q_{\text{jl}}(\mathbf{x}) = \operatorname{sign}(\mathbf{S}\mathbf{x}) \in \\{-1,+1}^d, \quad \widehat{\langle \mathbf{x},\mathbf{y}\rangle} = \frac{\sqrt{\pi/2}}{d}\, \langle \mathbf{S}\mathbf{y},\,Q_{\text{jl}}(\mathbf{x})\rangle.$

Each row $\mathbf{s}_i$ makes $\mathbf{s}_i\mathbf{x}$ and $\mathbf{s}_i\mathbf{y}$ jointly Gaussian with covariance $\langle\mathbf{x},\mathbf{y}\rangle$. The half-normal identity gives $\mathbb{E}[(\mathbf{s}_i\mathbf{y})\,\text{sign}(\mathbf{s}_i\mathbf{x})] = \sqrt{2/\pi}\cdot\langle\mathbf{x},\mathbf{y}\rangle/\|\mathbf{x}\|$. Sum over $d$ rows and multiply by $\sqrt{\pi/2}/d$: the $\sqrt{2/\pi}$ shrinkage cancels, and the result is $\langle\mathbf{x},\mathbf{y}\rangle$ in expectation. Variance is bounded by $\tfrac{\pi}{2d}\|\mathbf{x}\|^2\|\mathbf{y}\|^2$ (Lemma 4 of the paper).

Stretching it: TurboQuant-prod

QJL by itself uses one bit per coordinate. TurboQuant-prod extends the construction to a $b$-bit budget by allocating the bits between the two estimators from §6 and §8. The first $b{-}1$ bits encode $\boldsymbol{\Pi}\mathbf{x}$ with the MSE codebook of §6 to capture magnitude. The last bit encodes the residual $\mathbf{r} = \boldsymbol{\Pi}\mathbf{x} - \tilde{\mathbf{y}}_{\text{mse}}$ with QJL to make the inner-product estimate unbiased. The total cost is $b\cdot d$ bits plus one scalar per vector (the residual norm $\|\mathbf{r}\|$), the same as TurboQuant-MSE.

The full TurboQuant-prod recipe

1. Rotate $\mathbf{x}\to \boldsymbol{\Pi}\mathbf{x}$ as in §3.
2. Apply $(b{-}1)$-bit MSE-optimal quantization. Call the result $\tilde{\mathbf{y}}_{\text{mse}}$.
3. Form the residual $\mathbf{r} = \boldsymbol{\Pi}\mathbf{x} - \tilde{\mathbf{y}}_{\text{mse}}$ and quantize it with one bit of QJL: store $\text{sign}(\mathbf{S}\mathbf{r})$ and the residual norm $\|\mathbf{r}\|$.
4. Decode: $\tilde{\mathbf{x}} = \boldsymbol{\Pi}^{\top}\big(\tilde{\mathbf{y}}_{\text{mse}} + \|\mathbf{r}\|\cdot \tfrac{\sqrt{\pi/2}}{d}\,\mathbf{S}^{\top}\text{sign}(\mathbf{S}\mathbf{r})\big)$.

The residual norm is the only piece of side info in the whole scheme, one scalar per vector, not one per small block the way GPTQ, AWQ, or KIVI need. Variance is bounded by Theorem 2.

TAKEAWAY: NEXT

TurboQuant-MSE minimises reconstruction error and produces a biased inner-product estimate with a known shrinkage factor. TurboQuant-prod allocates one of its $b$ bits to a QJL residual and produces an unbiased inner-product estimate at higher per-trial variance. Both schemes use $b\cdot d$ bits plus one scalar per vector. Next: §9 compares both upper bounds against the information-theoretic lower bound.

Shannon's floor

How close is TurboQuant to the theoretical best?

The paper uses Shannon's lossy source-coding theorem (via Yao's minimax principle) to prove that no quantizer can do better than $D_{\text{mse}} \ge 4^{-b}$ on worst-case inputs on the unit sphere. The bound covers every conceivable quantizer, including randomized and data-adaptive ones. TurboQuant's matching upper bound is $\tfrac{\sqrt{3}\pi}{2}\cdot 4^{-b}$, within a factor of $\approx 2.7$ of the lower bound asymptotically and within a factor of $\approx 1.45$ at $b{=}1$.

The plot uses a log scale on the vertical axis. All three curves have the same slope (the $4^{-b}$ exponential rate) and differ only by a small constant offset.

The exponential improvement over older methods

Earlier data-oblivious quantizers (uniform rounding, scalar sketches) achieve a reconstruction error that decays only polynomially in the bit budget, e.g. $\mathcal{O}(1/b)$. TurboQuant's $4^{-b}$ rate is exponential in $b$. That exponential rate is what enables the 4–6× KV-cache compressions reported in §10 without measurable downstream quality loss.

TAKEAWAY: NEXT

The upper bound, the lower bound, and the measured error all decay at the same exponential rate.

MIT researchers have introduced Recursive Language Models (RLMs) to solve "context rot," a phenomenon where large language models experience reasoning degradation when processing massive context windows, even if they excel at basic retrieval tasks. Instead of forcing a model to ingest an entire document at once, an RLM loads the context into a Python REPL runtime memory slot.

American AI was financed on a particular bet. The bet was that frontier models would be the next great monopoly business — winner-take-all, capex-justified-by-monopoly, the kind of structurally protected market that supports trillion-dollar valuations and the capital flows necessary to build them. Two and a half years into the cycle, the assumption is breaking. Not slowly. Not at the edges. Visibly, in the public benchmarks, the open-source repos, the Hugging Face download counts, and the inference price sheets.

The break is straightforward to describe. Open-weight models — most of them released by Chinese labs, served through a stack of mostly Western open-source infrastructure — are commoditizing the capability that the moat was supposed to protect. Capability that a U.S. closed lab could charge enterprise rates for in 2024 is now available, downloadable, deployable on rented hardware, at single-digit cents on the dollar in 2026. The gap between the open frontier and the closed frontier is six to twelve months. It is closing, not widening.

The collision between those two facts — that American capital paid for a moat, and that the technology no longer provides one — is the most important force in the AI industry today. Everything else, including the policy direction the U.S. government will take in the next eighteen months, is downstream of how that collision resolves.

The Capital Thesis

To understand what is at stake, follow the money. U.S. frontier labs and their hyperscaler partners have committed somewhere on the order of a trillion dollars to AI capex over the next four years — data centers, GPU clusters, power infrastructure, fiber, the entire physical stack that frontier inference requires. Those commitments are not made on the assumption of SaaS-grade margins. SaaS-grade margins do not service that kind of capital base. The commitments were made on the assumption that frontier capability would behave, at scale, like a regulated monopoly: high fixed costs, high marginal margins, durable rents, very few competitors.

The valuations of the labs themselves reflect the same assumption. OpenAI, Anthropic, and the model arms of Google and Meta trade — privately, or via parent — at multiples that only resolve if frontier capability eventually commands monopoly-grade pricing. Strip out the monopoly assumption and the math does not work. The data centers are still there. The compute bills are still there. The investors who funded the build do not have a ready exit on a commodity-margin business.

That is the structural pressure. Frontier AI was financed as a moat. The financial commitments are durable and large. The technology that was supposed to provide the moat is failing to provide it. Capital, faced with that gap, does not quietly accept lower returns. Capital reaches for the moat through other means. That reach is what the next phase of U.S. AI policy will be about.

The Commons

The open-weight ecosystem did not arrive in stages. It arrived in a wave. In late 2024, a Chinese lab named DeepSeek released a model whose training cost was reported at roughly $5.6 million in compute, against an estimated $500 million to $1 billion for the U.S. closed-frontier equivalent it was benchmarked against. The performance gap on most general benchmarks ran six to twelve months. The performance gap on inference cost ran ten to thirty times in the open weight's favor. The model came under a permissive license, downloadable, modifiable, deployable on a single eight-GPU node by anyone with the storage and the patience to read the README.

That release was the leading edge, not the totality. By mid-2025, the open-weight frontier from the Chinese ecosystem — DeepSeek, Qwen, Kimi, GLM, MiniMax — had compounded into a competitive baseline. Llama, Mistral, and a dozen smaller community projects filled in the rest. The closed labs in the U.S. continued to win the very top of the capability curve. Below that top, the curve was being closed in from underneath at a pace that made the gap a six-to-twelve-month problem rather than a generational one.

What sits underneath the model release is the open ecosystem that delivers it. vLLM serves the weights at production-grade throughput. llama.cpp runs them on a developer's laptop. Ollama wraps the experience for the non-technical user. LangChain and LlamaIndex provide the orchestration layer that, two years ago, only existed inside OpenAI's product organization. None of these tools are owned by the closed labs. Most of them are American or Anglosphere open-source projects. The infrastructure is geographically and economically agnostic. The weights are not.

The Defection Problem

Last week's essay laid out an argument: that frontier AI is sold at a structural loss because users are providing the training data, and that when the apprenticeship ends, prices reprice upward sharply. There was an unstated premise in that argument. The premise was that when the prices rise, the user has nowhere to go.

That premise no longer holds. A consumer rationing a $250-per-month subscription at the moment of repricing has the option, today, of running an open-weight equivalent at fifteen dollars in cloud compute or zero dollars on a sufficiently equipped local machine. The defection cost is a weekend of integration work and a haircut on capability that, for most workloads, the user does not notice. For an enterprise the haircut is even smaller and the savings are larger.

That is a strategic problem for the closed labs, but it is a structural problem for U.S. capital. The original deal — subsidize, train, reprice — assumed lock-in at the moment of repricing. Lock-in does not exist if the next-best option is free. And if lock-in does not exist, the post-apprenticeship pricing the entire capital structure depends on does not exist either.

The valuations require a moat. The technology no longer provides one. Capital will reach for one anyway.

What Capitalism Does When Scarcity Disappears

There is a recurring move in industries where technology fails to provide the natural moat the financial structure assumed. The move is to manufacture scarcity through means other than the technology itself. American capitalism, despite its mythology, is unusually good at this. It has done it in pharmaceuticals, where patents and FDA exclusivity create monopolies the molecule alone could not. It has done it in finance, where regulatory complexity creates barriers to entry the underlying business of lending does not. It has done it in telecom, where spectrum allocation and right-of-way agreements substitute for technological superiority that competitive carriers would otherwise force.

The pattern is reliable enough to be predictable. When a technology produces something that wants to be a commodity, capital does not gracefully accept commodity returns. It reaches for three tools, in roughly this order. First, regulatory enclosure — using the policy apparatus to manufacture exclusion the market does not provide. Second, vertical integration — moving up or down the stack to capture margins the immediate product can no longer command. Third, bundled distribution — leveraging adjacent monopolies (cloud, ad networks, app stores, payment rails) to gate access to the commodity layer beneath.

All three of these tools are now being rehearsed in the U.S. AI sector. They are being rehearsed because the technology is producing a commodity, and the capital structure cannot survive a commodity. They will be deployed because the financial commitments are too large to walk away from. They will be deployed regardless of what is best for the user, because that is not what capital is selecting for at this stage of the cycle.

Three Predictions for the U.S. Direction

What that looks like in practice is a set of moves over the next eighteen to thirty-six months, mostly without legislation, mostly through the slow accumulation of advisories, procurement guidelines, and corporate practice. Three are likely enough to bet on.

1. Regulatory enclosure dressed as security.

The first move is the cheapest one. Chinese-origin open-weight models will be reframed as supply-chain risks — language already worn smooth by years of Huawei, ZTE, and DJI debate. The model card itself will be described as a vector for embedded behavior, the inference deployment as a potential exfiltration channel, the training data as suspect. None of those concerns are entirely without foundation. None of them are the actual reason for the policy. The actual reason is that the open-weight models are commoditizing capability the closed labs have already booked into their valuations.

The advisories will harden into procurement restrictions for federal agencies, then for federal contractors, then for critical infrastructure. Major U.S. cloud providers, watching the regulatory weather, will quietly delist Chinese-origin model endpoints from their managed services. The framing will not, at first, target individual developers running Qwen or DeepSeek weights on their own machines. But the institutional path of least resistance — for any cloud, any enterprise, any compliance officer — will be to treat Chinese-origin weights as the path that loses you contracts. That is enclosure achieved without a single new statute.

2. The labs become the operators.

The second move is the one the labs are already making, quietly and without much commentary. If selling the model produces commodity returns, the lab moves up the stack and sells the work the model does. The frontier capability runs internally; the customer-facing product is the output of that capability — legal research, software, drug discovery, financial analysis, whatever vertical the lab can structure into a service. The lab captures the operator's margin instead of the tool vendor's, and there is no tool to sell at any price.

From the capital structure's perspective, this is the cleanest path. From the user's perspective, it is the worst one. The lab is no longer trying to make the model accessible; it is trying to make the model inaccessible to the user's competitors, which includes the user. Vertical integration substitutes a margin the lab can defend (the operator's) for one it cannot (the tool vendor's). It is a rational move under capital pressure. It is also a structural retreat from the open ecosystem the original mission rhetoric described.

3. The market splits.

The third move is what happens to the rest of the world. U.S. domestic users — consumers, indie developers, mid-market companies — get the closed-frontier pricing the capital structure requires, with limited legal access to the open alternatives that would otherwise compete with it. The rest of the world routes around U.S. rails. European, Indian, Singaporean, and Latin American developers build on whichever combination of open and hosted endpoints sits in the cleanest jurisdiction. The U.S. closed-frontier business retains its margin in its protected market and loses share in every other market on Earth, on a multi-decade arc that mirrors the auto industry exactly.

The arithmetic is not subtle. The U.S. is roughly four percent of the world's population and perhaps fifteen percent of its consumer-facing technology market. Building a capital structure that requires the U.S. domestic market to absorb monopoly-grade rents, while accepting that the other eighty-five percent will route around the wall, is a strategy that produces excellent five-year balance sheets and disastrous twenty-year competitive positions. It is, nonetheless, the strategy. It is the one the capital flow already implies.

The Auto Mirror

There is a clean historical analogue. In 1980, U.S. domestic automakers controlled roughly 80% of the U.S. light-vehicle market. By 2024 that share was below 40%, and the global share was lower still. The arc of decline does not correlate with the absence of policy support. It correlates almost perfectly with the presence of it. Voluntary export restraints in the 1980s, repeated bailouts, and most recently a 100% tariff designed to keep BYD out of North America — none of those interventions reversed the trend. They lengthened it. The wall produced exactly what walls produce: protected margins, protected complacency, and a foreign competitor that compounded its advantage in every other market while the U.S. consumer paid more for less at home.

The same mechanism applies to AI. A walled domestic market lets the closed labs sustain the pricing the capital structure assumes. The protected balance sheets produce a generation of product that does not need to compete on cost. The open ecosystem outside the U.S. continues to compound. The gap between the protected industry and the global standard widens — in the wrong direction. By the time the wall is reconsidered, the protected industry no longer has a competitive product to bring outside of it.

The wall protects the producer. It does not protect the product. Twenty years on, the producer cannot compete without the wall, because the wall is what stopped them from learning to.

Who Pays

As with every protectionist regime, the cost lands on parties without lobbyists. Four cohorts come out behind.

• U.S. consumers and small developers — pay closed-frontier pricing for capability the rest of the world buys at commodity rates, with limited legal recourse to the open alternatives.
• U.S. independent developers and startups — either eat the closed-API premium, take architectural risk on a politically vulnerable open-weight stack, or relocate workloads to offshore endpoints. None of those options is free.
• U.S. closed-frontier labs themselves, on a long enough horizon — engineering and pricing discipline come only from competition. The protected producer eventually loses the ability to compete in the markets it isn't in.
• U.S. influence over the global AI ecosystem — every developer who routes around the wall does so on infrastructure outside U.S. control, and brings the relationships with them.

The beneficiaries are narrow and known. U.S. closed-frontier labs gain a margin window measured in years rather than decades. U.S. cloud providers extract some rent from compliance complexity. The capital that funded the build gets to mark its commitments at something other than zero. The political class earns a security narrative that polls well in election cycles. None of the beneficiaries are the median user. None of them are the median developer. None of them are the long-term competitive position of the country itself.

What To Do About It

The defensive move and the offensive move are the same move. There is a window in which the open commons remains accessible, and that window is open today. Three positionings make sense while it remains open.

• Build on the commons. Run open weights now, on infrastructure you control, for the workloads that pay for themselves today. The closed-frontier APIs remain useful for the very top of the capability curve, but the architecture should treat them as substitutable, not foundational.
• Architect for jurisdictional flexibility. The same compliance pressure that will eventually push Chinese open weights out of U.S. clouds will push U.S. workloads into European, Indian, and Singaporean endpoints. That is not a contingency; it is an architectural concern. Plan for it now, while the migration is voluntary.
• Treat the policy clock as part of the stack. The window between freely deployable open-weight models and open-weight models restricted to compliant entities under a guidance document is shorter than the design cycle of most production systems. Anything mission-critical built on the assumption of permanent open access to current-generation Chinese weights is a trapdoor.

The Closing Frame

American capitalism is unusually good at allocation and unusually poor at abundance. When a technology produces commodity capability, the U.S. capital structure does not gracefully reorganize around the new economics. It reaches for the policy levers that can manufacture the scarcity the technology has stopped providing. This is not a moral failing. It is a structural consequence of how the system finances itself. The same dynamic that made it possible to fund a trillion dollars of AI infrastructure on the back of a monopoly thesis now requires the monopoly to be defended by means other than the underlying technology.

The collision between that financial logic and the open-weight commons is the central force in the U.S. AI industry over the next decade. The capital structure will fight to manufacture scarcity. The commons will continue to compound. The user — domestic and global — sits in between. The choice the country makes about how heavily to wall the domestic market against the commons will determine whether U.S. AI looks like the U.S. internet sector in 2005 — open, exporting, dominant — or like the U.S. auto industry in 2025 — protected, exporting nothing, durably uncompetitive.

That is the actual question. Not whether open weights threaten frontier labs, because they obviously do. Not whether the labs and their capital partners will reach for protection, because they obviously will. The question is whether the country that hosts that fight chooses to subsidize the moat or the commons. So far, the choice is going one way. The moat or the commons. American capital prefers the first. American consumers, developers, and long-term competitiveness need the second. The next decade resolves which preference the policy follows.

NVIDIA's latest GPU rental prices on the Ornn Compute Price Index hit $4.95 per hour this week, up from $2.31 in early March : a 114% surge in six weeks.1

The price spread over prior-generation chips doubled from $0.28 to $1.80 per hour. The new chip is NVIDIA's B200 (Blackwell); the prior generation is the H200 (Hopper).

The GPU market is becoming lucid - even if the fog hasn't lifted.

1. Frontier model releases correlate with demand shocks

The price spikes line up with major model launches. Every major model release since September 2025 preceded or coincided with jumps in B200 pricing.

GPT-5.5's expanded context window requires the memory headroom that only Blackwell provides.2

The correlation isn't perfect. Supply shocks matter too. But the pattern is clear : newer models need newer chips.

2. The gap between cheapest & most expensive providers is blowing out

In September 2025, B200 prices across providers clustered tightly. Today the spread has more than doubled. Some providers still offer B200 at near-H200 prices. Others command scarcity premiums.

This bears the hallmarks of an opaque market with big supply/demand shocks. When is a hyperscaler receiving a new delivery? Which AI startup overbought capacity & is now selling at a discount? Opaque everywhere you look.

3. The B200-over-H200 price gap collapsed, then recovered

When B200 came to market in September 2025, it cost more per hour than H200. Buyers paid up for the extra memory & inference density.

By November, that gap collapsed to $0.28 as supply flooded the market. For a brief window, B200 & H200 reached near price parity.

Since February when GPT-5.3-Codex launched, the spread re-widened. The current $1.80 gap is back near launch levels.

The widening gap is also a depreciation signal : older chips lose value when new models demand new architectures.

For cloud providers, pricing power is returning. After six months of margin compression, the sellers' market is back.

For AI startups, the spot market leads contract pricing by ~90 days. B200 likely settles above $5.00 for the summer.

For model builders, inference at the frontier is getting more expensive.

Inflationary demand outpaces deflationary algorithmic & chip improvements, but the fog of the GPU market continues.

1. Ornn Compute Price Index, daily index values for B200 & H200 GPUs, Sep 2025 – Apr 2026. ↩︎

2. OpenAI, "Introducing GPT-5.5," Apr 23, 2026. ↩︎

Xiaomi MiMo-V2.5-Pro

A leap in agentic and long horizon coherence.

Today, we are releasing and open-sourcing MiMo-V2.5-Pro. It is our most capable model to date, delivering significant improvements over its predecessor, MiMo-V2-Pro, in general agentic capabilities, complex software engineering, and long-horizon tasks. MiMo-V2.5-Pro is a 1.02T-parameter Mixture-of-Experts model with 42B active parameters, built on a hybrid-attention architecture with a 1M-token context window.

In internal testing, V2.5-Pro demonstrated a new level of intelligence that, in turn, pushed our researchers to rethink how they work with it. When paired with a proper harness, V2.5-Pro can sustain complex, long-horizon tasks spanning more than a thousand tool calls. We also see substantial improvements in instruction following within agentic scenarios. It reliably adheres to subtle requirements embedded in context and maintains strong coherence across ultra-long contexts.

MiMo-V2.5-Pro is now fully rolled out across our API Platform, AI Studio, and other surfaces, with no change in pricing. Simply replace the model tag with mimo-v2.5-pro to get started.

Built to Solve Harder

MiMo-V2.5-Pro is built for harder goals. We've given it tasks that would take human experts days or weeks, and let it run autonomously. Here's what it delivers:

SysY Compiler in Rust

Sourced from Peking University's Compiler Principles course project, this task asks the model to implement a complete SysY compiler in Rust from scratch: lexer, parser, AST, Koopa IR codegen, RISC-V assembly backend, and performance optimization. The reference project typically takes a PKU CS major student several weeks. MiMo-V2.5-Pro finished in 4.3 hours across 672 tool calls, scoring a perfect 233/233 against the course's hidden test suite.

Rather than thrashing through trial and error, the model built the compiler layer by layer: scaffold the full pipeline first, perfect Koopa IR (110/110), then the RISC-V backend (103/103), then performance (20/20). The first compile alone passed 137/233 tests, a 59% cold start that suggests the architecture was designed correctly before a single test was run. At turn 512 a refactoring pass regressed lv9/riscv by two tests; the model diagnosed the failures, recovered, and pushed on. Long-horizon work rewards this kind of structured, self-correcting discipline.

A Full-Featured Video Editor

With just a few simple prompts, MiMo-V2.5-Pro delivered a working desktop app: multi-track timeline, clip trimming, cross-fades, audio mixing, and export pipeline. The final build is 8,192 lines of code, produced over 1,868 tool calls across 11.5 hours of autonomous work.

Analog EDA: FVF-LDO Design & Optimization

A graduate-level analog-circuit EDA task: design and optimize a complete FVF-LDO (Flipped-Voltage-Follower low-dropout regulator) from scratch in the TSMC 180nm CMOS process. The model has to size the power transistor, tune the compensation network, and pick bias voltages so that six metrics land within spec simultaneously — phase margin, line regulation, load regulation, quiescent current, PSRR, and transient response. A trained analog designer typically spends several days on a project of this scope.

We wired MiMo-V2.5-Pro into an ngspice simulation loop with Claude Code as the harness. In about an hour of closed-loop iteration — calling the simulator, reading waveforms, tweaking parameters — the model produced a design where every target metric is met, and the four shown below are improved by an order of magnitude over its own initial attempt.

Throughout these experiments, V2.5-Pro exhibits a remarkable "harness awareness": it makes full use of the affordances of its harness environment, manages its memory, and shapes how its own context is populated toward the final objective.

Frontier Coding Intelligence

We further advanced the model's coding intelligence by scaling post-training compute.

MiMo Coding Bench is our in-house evaluation suite for assessing models' ability to handle diverse coding tasks within agentic frameworks such as Claude Code. It covers repo understanding, project building, code review, structured artifact generation, planning, SWE, and more. MiMo-V2.5-Pro further enhances the user experience in real-world coding scenarios, better handling a wide variety of development needs.

We welcome developers worldwide to integrate MiMo-V2.5 series into scaffolds such as Claude Code, OpenCode, and Kilo — accessing top-tier intelligence at a lower cost.

Token Efficiency

Higher intelligence isn't just about higher scores — it's about getting there with fewer tokens. MiMo-V2.5-Pro reaches frontier-tier capability while spending dramatically less on tokens per trajectory. On ClawEval, V2.5-Pro lands at 64% Pass^3 using only ~70K tokens per trajectory — roughly 40–60% fewer tokens than Claude Opus 4.6, Gemini 3.1 Pro, and GPT-5.4 at comparable capability levels. The upper-left corner of the chart is where you want to be: higher score for lower cost.

Token Plan Updates

Alongside a stronger model, we've also upgraded our inference infrastructure. The Token Plan now comes with a few meaningful improvements:

All users who purchased a Token Plan before 14:00 UTC on April 21 will have their used Credit balance reset.

Open Source

MiMo-V2.5-Pro is now fully open-sourced under a permissive license. Weights, tokenizer, and the full model card are available on Hugging Face.

Model specifications

Architecture & training

MiMo-V2.5-Pro inherits the hybrid attention and Multi-Token Prediction (MTP) design from MiMo-V2-Flash. Local Sliding Window Attention (SWA) and Global Attention (GA) are interleaved at a 6:1 ratio with a 128-token window, which cuts KV-cache storage by nearly 7× at long context while preserving performance through a learnable attention-sink bias. A lightweight MTP module with dense FFNs is natively integrated for training and inference, roughly tripling output throughput and accelerating RL rollouts.

Pre-training runs on 27T tokens using FP8 mixed precision at a native 32K sequence length, with context extended up to 1M tokens. Post-training follows the three-stage paradigm introduced in MiMo-V2-Flash: (1) Supervised Fine-Tuning to establish foundational instruction following on curated data pairs; (2) Domain-Specialized Training, where separate teacher models are each optimized via domain-specific RL across math, safety, agentic tool-use, and more; and (3) Multi-Teacher On-Policy Distillation (MOPD), where a single student model learns on-policy from its own rollouts under token-level guidance from every specialist teacher, merging their capabilities into one unified model.

See the model card on Hugging Face for architecture details, evaluation tables, and deployment guides for SGLang and vLLM.

Full benchmark results

• A former Google DeepMind researcher announced on Monday a record $1.1 billion for his new AI lab.
• Ineffable Intelligence garnered backing from Sequoia, Lightspeed, Nvidia and Google, and emerged from stealth with a $5.1 billion valuation.
• Silver is one of a number of former top researchers at Big Tech companies who've jumped ship to launch their own AI labs in recent months.

A former top researcher at Google AI division DeepMind announced Monday a record $1.1 billion seed round for his months-old startup, Ineffable Intelligence.

The startup is pursuing superintelligence and was founded in late 2025 by UCL professor and former lead of DeepMind's reinforcement learning team, David Silver. The seed round is the largest ever in Europe, according to the company, amounting to a valuation of $5.1 billion.

The round was co-led by U.S. venture capitalists Sequoia and Lightspeed, with participation from Nvidia , DST Global, Index, Google and the U.K.'s Sovereign AI Fund, among others.

Ineffable Intelligence will focus on reinforcement learning, which is when artificial intelligence models learn from experience as opposed to human data. That compares with many leading AI models that are trained on internet text.

Silver said the company is aiming to "transcend the greatest inventions in human history, such as language, science, mathematics and technology."

"Our mission is to make first contact with superintelligence," said Silver in a statement.

"We are creating a superlearner that discovers all knowledge from its own experience, from elementary motor skills through to profound intellectual breakthroughs," he added.

Big Tech talent exodus fuels startup boom

Silver is one of several former top researchers at Big Tech companies who've jumped ship to launch their own AI labs in recent months, with investors funneling billions of dollars into the ventures.

Last week, a months-old startup called Recursive Superintelligence — founded by former Google DeepMind engineer Tim Rocktäschel — was reported by the Financial Times to be raising up to $1 billion. AMI Labs announced a $1 billion raise in March, months after its founder, Yann LeCun, announced he was leaving his role as Meta 's AI chief.

In the past year, former staff at OpenAI, DeepMind, Anthropic and xAI have also raised hundreds of millions from investors for months-old ventures, including AI labs Periodic Labs and Humans&.

"This investment in Ineffable will support a company at the very frontier of AI, with the potential to transform entire sectors, underlining our determination to ensure that the UK isn't just an AI taker but an AI maker," the U.K's Science and Technology secretary, Liz Kendall, said in a statement.

The promotional discount runs until 5 May 2026. Even at full price, V4-Pro already undercuts GPT-5.5, Claude Opus 4.7, and Gemini 3.1 Pro on per-token costs.

The move is a direct challenge to the pricing strategy of US AI providers at a moment when the Trump administration has accused Chinese firms of distilling American AI models on an industrial scale.

DeepSeek announced on Monday that it is offering a 75% discount on its newly released DeepSeek-V4-Pro model to developers until 5 May 2026, and is simultaneously cutting the price of input cache hits across its entire API suite to one-tenth of previous levels, effective immediately.

The discount was announced in a post on X. The move intensifies a pricing competition with US AI providers that DeepSeek first triggered in January 2025 with its R1 model, which claimed frontier-level reasoning performance at a fraction of the cost of comparable OpenAI products.

The pricing context is important. At full price, before any promotional discount, DeepSeek-V4-Pro already costs $0.145 per million input tokens and $3.48 per million output tokens, undercutting OpenAI's GPT-5.5, Google's Gemini 3.1 Pro, and Anthropic's Claude Opus 4.7 on per-token basis.

The 75% promotional discount on input tokens reduces the V4-Pro input price to approximately $0.036 per million tokens. The Flash variant, V4's smaller, faster model, costs $0.14 per million input tokens and $0.28 per million output tokens at full price, already undercutting GPT-5.4 Nano, Gemini 3.1 Flash, GPT-5.4 Mini, and Claude Haiku 4.5.

The cache-hit price cut to one-tenth of prior levels specifically targets frequent users and enterprise developers who send similar or repeated requests, which is the dominant pattern in production agentic applications.

The strategic logic is explicit and well-documented in how DeepSeek has operated since R1. Open-source availability removes the model access barrier entirely; aggressive API pricing removes the cost barrier for production deployment; a 1 million-token context window makes the model viable for enterprise use cases involving large codebases or long documents that would otherwise require multiple API calls.

V4-Pro also integrates natively with Claude Code, OpenClaw, and OpenCode, the dominant agentic coding frameworks used by developers already in the Western AI ecosystem.

The combined effect is to lower the friction of switching from an OpenAI, Anthropic, or Google API to a DeepSeek API for any developer whose primary constraint is cost. Akshar Keremane, co-founder of Bangalore-based AI startup O-Health, described the combination of pricing, open-source availability, and the 1 million-token context window as lowering barriers "for developers, startups and small enterprises."

The V4-Pro model, launched last Friday, is a mixture-of-experts model with 1.6 trillion total parameters and 49 billion active parameters per task, the largest open-weight model currently available, outstripping Moonshot AI's Kimi K2.6 and MiniMax's M1.

Its Hybrid Attention Architecture is designed to maintain coherence across long contexts. It is trained on and optimised for Huawei's Ascend 950 chips and Cambricon hardware rather than Nvidia GPUs.

Zhang Yi, founder of tech research firm iiMedia, told AFP that V4's architecture represents a "genuine inflection point" for long-context AI processing, predicting that ultra-long context support will move beyond research labs into mainstream commercial applications.

Wei Sun, principal analyst at Counterpoint Research, noted that V4 running on domestic chips "allows AI systems to be built and deployed without relying solely on Nvidia" and could "accelerating adoption domestically and contributing to faster global AI development overall."

The pricing move arrives in a charged geopolitical context. On Thursday last week, White House Director of Science and Technology Policy Michael Kratsios accused foreign entities, primarily based in China, of conducting "industrial-scale" campaigns to distil frontier AI models from US companies, a process in which a smaller model is trained using the outputs of a larger model to acquire similar capabilities at lower cost.

Kratsios's memo did not directly name DeepSeek, but DeepSeek has previously been accused by both Anthropic and OpenAI of distilling their models. CNN reported it has reached out to DeepSeek for comment on those accusations.

The US government's distillation crackdown, alongside China's parallel move to restrict US investment in its AI firms, was announced the day before V4's launch.

DeepSeek's response, three days later, is to cut prices rather than respond to the accusations directly: a competitive move that is also a political statement about where it believes the AI race will ultimately be decided.

OpenAI has cut API prices multiple times; Anthropic has introduced tiered pricing for different Claude model sizes; Google has progressively reduced Gemini API costs.

DeepSeek's Monday announcement is the latest move in that ongoing compression, but it is distinctive in its scale, a 75% promotional discount on top of a model that already undercuts the US frontier at standard pricing, and in its timing, which positions the Hangzhou startup as the low-cost challenger in the same week that OpenAI shipped GPT-5.5 and the US government moved to restrict Chinese model distillation.

OpenAI plans to launch its first phone in 2028. The company is working with MediaTek and Qualcomm to develop smartphone processors. Mass production is expected to start in 2028. Specifications and suppliers are expected to be finalized by late 2026 or Q1 2027. The phone will likely heavily utilize AI agents, making it work and feel very different from current smartphones.

Meta has agreed to purchase up to a gigawatt of solar power from Overview Energy, a startup that aims to deploy satellites capable of providing power to customers on Earth. Overview is working toward an in-space demonstration in 2028. It will target commercial service two years after that. The company is currently developing the satellites along with the production lines to manufacture them.

Advanced semiconductors are the most important technology in the world. However, everyone who hopes to manufacture semiconductors is dependent on ASML, a relatively obscure Dutch company. ASML makes the only machines in the world capable of stenciling the transistors onto a chip with the precision necessary to fit billions on a 30-centimeter wafer. This article tells the story of how ASML overtook its competition to become the sole supplier of these machines.

Symphony

Symphony turns project work into isolated, autonomous implementation runs, allowing teams to manage work instead of supervising coding agents.

In this demo video, Symphony monitors a Linear board for work and spawns agents to handle the tasks. The agents complete the tasks and provide proof of work: CI status, PR review feedback, complexity analysis, and walkthrough videos. When accepted, the agents land the PR safely. Engineers do not need to supervise Codex; they can manage the work at a higher level.

Warning: Symphony is a low-key engineering preview for testing in trusted environments.

Running Symphony

Requirements

Symphony works best in codebases that have adopted harness engineering. Symphony is the next step -- moving from managing coding agents to managing work that needs to get done.

Option 1. Make your own

Tell your favorite coding agent to build Symphony in a programming language of your choice:

Implement Symphony according to the following spec: https://github.com/openai/symphony/blob/main/SPEC.md

Option 2. Use our experimental reference implementation

Check out elixir/README.md for instructions on how to set up your environment and run the Elixir-based Symphony implementation. You can also ask your favorite coding agent to help with the setup:

Set up Symphony for my repository based on https://github.com/openai/symphony/blob/main/elixir/README.md

Agent Memory Patterns

Say you get asked to "add memory" to an agent. What does that mean? How do you do it?

There's three common kinds of mutable memory:

1. Files
2. Memory blocks
3. Skills

If you don't need the agent to learn, then you're looking in the wrong place. You don't need memory. But this post might also be useful if you're just using agents, like a coding agent.

Files are for data & knowledge

Everything in this post needs to satisfy the following functions:

1. Explore to find items — ls, find, grep, or equivalent tools
2. Read an item — cat, or some ReadFile tool
3. Write an item — pipe, sed, or some WriteFile tool

For files, all that seems fairly obvious. Files can be complicated, but those are the parts that are important for files to work as agent memory. Files don't have to be literal files. If they are, you can provide a Bash tool (or Powershell) that gives you cool Linux utilities for navigating the filesystem, reading parts of files, etc.

But also, you can absolutely use database records or S3 blobs. As long as:

1. Each file has a hierarchical path, to enable exploring, but also so that files are a key-value store
2. Long text content. We don't care too much about file structure or validation, but please do give the agent space to work.

Memory blocks are a learnable system prompt

Memory blocks are just a flat key-value store. Except the key isn't used for looking things up, it's just used for writing. All memory blocks are included inline in the system prompt, or user prompt.

Where to put it?

• System prompt — this one's easier in a lot of systems. But can cause cache invalidation (higher token cost) when the agent calls WriteBlock.
• User prompt (prepend) — This also works, it's still highly visible to the LLM, and it causes less prompt cache invalidation issues.

Either is fine. User prompt is slightly better, I guess.

Required tools:

• WriteBlock(key, value [, sort_order]) — I like including a sort_order, because we know order does matter, so let the agent control it too. Not a huge deal though.

Optional tools:

• ListBlocks()
• ReadBlock(key)

Theoretically you don't need these because they're in the prompt already, but I've noticed that coding agents will always try to insert them and agent agents will always call them, every time. So, whatever that means..

What goes into blocks?

Blocks are a learnable system prompt. Put stuff in there that tends to go into the system prompt — behavior, preferences, identity, character, etc.

Since it's in the prompt, the agent can't look away or ignore. So you may want to promote from file to block if you want to guarantee visibility, like you don't want to risk the agent forgetting to read a file.

Skills are indexed files

Skills are a combination of files & memory blocks. They're files, literally, but they also are represented in the system prompt.

It's just a directory with a SKILL.md file:

the-skill/
  SKILL.md
  important-concept-1.md
  helper-script.py
  worksheet.csv

The SKILL.md is generally just a plain markdown file, but it has a special top few lines at the start of the file:

---
name: the-skill
description: what it does and when to use it
---

The description is the critial part. Both name and description go into the system prompt, but the description is the trigger. It encourages the agent to use the skill in the right circumstance.

Do you need a Skill tool?

Not really. Claude Code has a Skill(name) tool, but functionally it's the same as the agent reading the-skill/SKILL.md with a regular Read tool. The benefits are harness-side: lazy-loading the SKILL.md content (so it only enters the context window when invoked), telemetry, and permission scoping.

If you skip the dedicated tool, just tell the agent in the system prompt: "When a skill matches, read its SKILL.md before doing the thing." Works fine.

What goes into skills?

Data or instructions that are only needed in certain circumstances. Honestly "skill" is actually a really good name for them.

The key phrase is progressive disclosure — skills unfold as needed. The agent reads files as it deems necessary. Typically you'll include file references in the SKILL.md file, like "Read important-concept-1.md when you need to…". There's nothing special, no notation, it's just hints for the agent.

Scripts and data are nice too. Obviously scripts are only useful if you enable a Bash tool, but scripts especially can act like a agent optimizer. Like, sure, the agent can probably figure out how to string together all the headers to authenticate to your weird API, or you can just make a script for it and skip the LLM.

Editable skills

Most people think of skills as being immutable programs of English. Sure, they're useful when used like that, but they're even more useful when you allow your agent to change them.

A great way to use skills is as an experience cache. At the end of a long investigation or research, have the agent record the experience in a skill. Next time, it just reads the skill! Could you use files for this? Yes, but the description field in the system prompt makes it more likely to be used at the right time.

Observability

How do you know when the agent is using memory well?

For files & skills, you can start at the entry point and construct a graph of which files reference which other files:

1. For each file
2. Search for the file name
3. Pair "file referenced from" → file

Then compare against reality. Find all the times those files were accessed in that order versus not. If they're referenced randomly, that means the agent needs to use Search or ListFiles tools to navigate. That might mean your files or skills are becoming too unwieldy.

Also, you should monitor memory block size & count. Definitely keep them under 5000, probably under 500 characters. When the blocks get too big, they tend to confuse the agent.

Unfortunately, given the nature of agents, there's not that much you can do for observability. But these two things do tend to be useful to monitor.

Search index

Is a search index a good idea? Yes absolutely. It's just annoying.

Seriously, it adds a data asset that needs to be maintained. Most of the time that's not a huge deal, but when it is, it is. Your call.

Git is an agent database

I highly recommend versioning files & ideally also skills & memory blocks. In open-strix I store memory blocks in yaml so they version and diff cleanly.

Versioning gives you checkpoints and lets you see evolution. It also lets you rollback or let the agent discover when a bad change was made. I've tried to use branching and merging, but not successfully.

Bad ideas

Knowledge graphs and other writable data models, e.g. backend by SQL, tend to not work very well because the LLM's weights doesn't know about their schemas. Most people talk themselves into knowledge graphs because they have structure and historically structure has been good. But the only structure LLMs need is tokens. They reason just fine in token space.

Good (but weirder) ideas

I've discovered that some types of generic data structures can be very useful for agents, for special purposes.

Issue trackers are oddly useful. I've been using chainlink, which is an issue tracker specifically for agents, but I've heard Asana also works fine. Probably any issue tracker would work. An issue tracker gives you a searchable work queue.

I've added an interest backlog to all of my agents now. Any time they come across something weird, interesting, or annoying they can create an issue and tag it interest. Then, during the night while I sleep they work through the backlog. This has led to multiple agents making connections between ideas & things I hadn't discovered yet, and generally coming up with fresh ideas that feel honestly novel.

Also, an append-only log is super useful. I have an events.jsonl file that goes into all of my agents. The agent harness writes every single event that happens, like tool calls and messages, and appends a JSON object minified to the events.jsonl file. It's not writable memory in the normal sense, but the agent can read it to give grounded answers about what it actually did.

Conclusion

Editable memory is extremely powerful. I highly recommend trying it out. Hopefully this helped.

OpenAI and Microsoft have forged a new deal that gives OpenAI the freedom to partner with anyone, caps the revenue OpenAI must share with Microsoft through 2030, and removes a clause that allowed OpenAI to limit Microsoft's access to its future technology when systems reach the AGI threshold. The relationship between the two companies was strained last year in part because of the control Microsoft had over OpenAI's intellectual property and exclusivity agreements. The revised deal offers greater predictability for the companies.

China's state planner on Monday called for Meta to unwind its $2 billion acquisition of Manus, a Singaporean artificial intelligence startup with Chinese roots.

The decision to prohibit foreign investment in Manus was made in accordance with laws and regulations, the National Development and Reform Commission said in a brief statement. It added that it has asked the parties involved to withdraw the acquisition transaction.

Shares of Meta closed 0.53% higher on Monday.

The deal had attracted scrutiny from both China and Washington, as lawmakers in the U.S. have prohibited American investors from backing Chinese AI companies directly. Meanwhile, Beijing has increased efforts to discourage Chinese AI founders from moving business offshore.

The Chinese government's intervention in the transaction drew alarm among tech founders and venture capitalists in the country who were hoping to take advantage of the so-called Singapore-washing model, where companies relocate from China to the city-state to avoid scrutiny from Beijing and Washington.

Manus was founded in China before relocating to Singapore. The company develops general-purpose AI agents and launched its first general AI agent in March last year, which can execute complex tasks such as market research, coding and data analysis. The release saw the startup lauded as the next DeepSeek.

Manus said it had passed $100 million in annual recurring revenue, or ARR, in December, eight months on from launching a product, which it claimed made it the fastest startup in the world at the time to hit the milestone from $0.

The company raised $75 million in a round led by U.S. VC Benchmark in April last year.

When Meta announced the deal late last year, the tech giant said it would look to accelerate artificial intelligence innovation for businesses and integrate advanced automation into its consumer and enterprise products, including its Meta AI assistant.

But in January, China's Ministry of Commerce said it would conduct an assessment and investigation into how the acquisition complied with laws and regulations concerning export controls, technology import and export, and overseas investment.

A Meta spokesperson told CNBC that the transaction "complied fully with applicable law," and that it anticipated "an appropriate resolution to the inquiry."

When asked about China's move to block Meta's acquisition of Manus, APEC Senior Officials Meeting Chairman Chen Xu told reporters that it is "important that all parties act in a spirit of mutual benefit."

While Chen said he did not know the specifics of the issue, he said that "if such an issue can be handled properly, it can help facilitate more substantive discussions in APEC." That's according to an official English translation.

The Windows K2 plan involves a marathon of updates introduced over time to fix problems in Windows.

OpenAI's Chief Financial Officer is worried the company might not be able to pay for future computing contracts if revenue doesn't grow fast enough.

The Moat or the Commons

American AI was financed on a particular bet. The bet was that frontier models would be the next great monopoly business — winner-take-all, capex-justified-by-monopoly, the kind of structurally protected market that supports trillion-dollar valuations and the capital flows necessary to build them. Two and a half years into the cycle, the assumption is breaking. Not slowly. Not at the edges. Visibly, in the public benchmarks, the open-source repos, the Hugging Face download counts, and the inference price sheets.

The break is straightforward to describe. Open-weight models — most of them released by Chinese labs, served through a stack of mostly Western open-source infrastructure — are commoditizing the capability that the moat was supposed to protect. Capability that a U.S. closed lab could charge enterprise rates for in 2024 is now available, downloadable, deployable on rented hardware, at single-digit cents on the dollar in 2026. The gap between the open frontier and the closed frontier is six to twelve months. It is closing, not widening.

The collision between those two facts — that American capital paid for a moat, and that the technology no longer provides one — is the most important force in the AI industry today. Everything else, including the policy direction the U.S. government will take in the next eighteen months, is downstream of how that collision resolves.

The Capital Thesis

To understand what is at stake, follow the money. U.S. frontier labs and their hyperscaler partners have committed somewhere on the order of a trillion dollars to AI capex over the next four years — data centers, GPU clusters, power infrastructure, fiber, the entire physical stack that frontier inference requires. Those commitments are not made on the assumption of SaaS-grade margins. SaaS-grade margins do not service that kind of capital base. The commitments were made on the assumption that frontier capability would behave, at scale, like a regulated monopoly: high fixed costs, high marginal margins, durable rents, very few competitors.

The valuations of the labs themselves reflect the same assumption. OpenAI, Anthropic, and the model arms of Google and Meta trade — privately, or via parent — at multiples that only resolve if frontier capability eventually commands monopoly-grade pricing. Strip out the monopoly assumption and the math does not work. The data centers are still there. The compute bills are still there. The investors who funded the build do not have a ready exit on a commodity-margin business.

That is the structural pressure. Frontier AI was financed as a moat. The financial commitments are durable and large. The technology that was supposed to provide the moat is failing to provide it. Capital, faced with that gap, does not quietly accept lower returns. Capital reaches for the moat through other means. That reach is what the next phase of U.S. AI policy will be about.

The Commons

The open-weight ecosystem did not arrive in stages. It arrived in a wave. In late 2024, a Chinese lab named DeepSeek released a model whose training cost was reported at roughly $5.6 million in compute, against an estimated $500 million to $1 billion for the U.S. closed-frontier equivalent it was benchmarked against. The performance gap on most general benchmarks ran six to twelve months. The performance gap on inference cost ran ten to thirty times in the open weight's favor. The model came under a permissive license, downloadable, modifiable, deployable on a single eight-GPU node by anyone with the storage and the patience to read the README.

That release was the leading edge, not the totality. By mid-2025, the open-weight frontier from the Chinese ecosystem — DeepSeek, Qwen, Kimi, GLM, MiniMax — had compounded into a competitive baseline. Llama, Mistral, and a dozen smaller community projects filled in the rest. The closed labs in the U.S. continued to win the very top of the capability curve. Below that top, the curve was being closed in from underneath at a pace that made the gap a six-to-twelve-month problem rather than a generational one.

What sits underneath the model release is the open ecosystem that delivers it. vLLM serves the weights at production-grade throughput. llama.cpp runs them on a developer's laptop. Ollama wraps the experience for the non-technical user. LangChain and LlamaIndex provide the orchestration layer that, two years ago, only existed inside OpenAI's product organization. None of these tools are owned by the closed labs. Most of them are American or Anglosphere open-source projects. The infrastructure is geographically and economically agnostic. The weights are not.

The Defection Problem

Last week's essay laid out an argument: that frontier AI is sold at a structural loss because users are providing the training data, and that when the apprenticeship ends, prices reprice upward sharply. There was an unstated premise in that argument. The premise was that when the prices rise, the user has nowhere to go.

That premise no longer holds. A consumer rationing a $250-per-month subscription at the moment of repricing has the option, today, of running an open-weight equivalent at fifteen dollars in cloud compute or zero dollars on a sufficiently equipped local machine. The defection cost is a weekend of integration work and a haircut on capability that, for most workloads, the user does not notice. For an enterprise the haircut is even smaller and the savings are larger.

That is a strategic problem for the closed labs, but it is a structural problem for U.S. capital. The original deal — subsidize, train, reprice — assumed lock-in at the moment of repricing. Lock-in does not exist if the next-best option is free. And if lock-in does not exist, the post-apprenticeship pricing the entire capital structure depends on does not exist either.

The valuations require a moat. The technology no longer provides one. Capital will reach for one anyway.

What Capitalism Does When Scarcity Disappears

There is a recurring move in industries where technology fails to provide the natural moat the financial structure assumed. The move is to manufacture scarcity through means other than the technology itself. American capitalism, despite its mythology, is unusually good at this. It has done it in pharmaceuticals, where patents and FDA exclusivity create monopolies the molecule alone could not. It has done it in finance, where regulatory complexity creates barriers to entry the underlying business of lending does not. It has done it in telecom, where spectrum allocation and right-of-way agreements substitute for technological superiority that competitive carriers would otherwise force.

The pattern is reliable enough to be predictable. When a technology produces something that wants to be a commodity, capital does not gracefully accept commodity returns. It reaches for three tools, in roughly this order. First, regulatory enclosure — using the policy apparatus to manufacture exclusion the market does not provide. Second, vertical integration — moving up or down the stack to capture margins the immediate product can no longer command. Third, bundled distribution — leveraging adjacent monopolies (cloud, ad networks, app stores, payment rails) to gate access to the commodity layer beneath.

All three of these tools are now being rehearsed in the U.S. AI sector. They are being rehearsed because the technology is producing a commodity, and the capital structure cannot survive a commodity. They will be deployed because the financial commitments are too large to walk away from. They will be deployed regardless of what is best for the user, because that is not what capital is selecting for at this stage of the cycle.

Three Predictions for the U.S. Direction

What that looks like in practice is a set of moves over the next eighteen to thirty-six months, mostly without legislation, mostly through the slow accumulation of advisories, procurement guidelines, and corporate practice. Three are likely enough to bet on.

1. Regulatory enclosure dressed as security.

The first move is the cheapest one. Chinese-origin open-weight models will be reframed as supply-chain risks — language already worn smooth by years of Huawei, ZTE, and DJI debate. The model card itself will be described as a vector for embedded behavior, the inference deployment as a potential exfiltration channel, the training data as suspect. None of those concerns are entirely without foundation. None of them are the actual reason for the policy. The actual reason is that the open-weight models are commoditizing capability the closed labs have already booked into their valuations.

The advisories will harden into procurement restrictions for federal agencies, then for federal contractors, then for critical infrastructure. Major U.S. cloud providers, watching the regulatory weather, will quietly delist Chinese-origin model endpoints from their managed services. The framing will not, at first, target individual developers running Qwen or DeepSeek weights on their own machines. But the institutional path of least resistance — for any cloud, any enterprise, any compliance officer — will be to treat Chinese-origin weights as the path that loses you contracts. That is enclosure achieved without a single new statute.

2. The labs become the operators.

The second move is the one the labs are already making, quietly and without much commentary. If selling the model produces commodity returns, the lab moves up the stack and sells the work the model does. The frontier capability runs internally; the customer-facing product is the output of that capability — legal research, software, drug discovery, financial analysis, whatever vertical the lab can structure into a service. The lab captures the operator's margin instead of the tool vendor's, and there is no tool to sell at any price.

From the capital structure's perspective, this is the cleanest path. From the user's perspective, it is the worst one. The lab is no longer trying to make the model accessible; it is trying to make the model inaccessible to the user's competitors, which includes the user. Vertical integration substitutes a margin the lab can defend (the operator's) for one it cannot (the tool vendor's). It is a rational move under capital pressure. It is also a structural retreat from the open ecosystem the original mission rhetoric described.

3. The market splits.

The third move is what happens to the rest of the world. U.S. domestic users — consumers, indie developers, mid-market companies — get the closed-frontier pricing the capital structure requires, with limited legal access to the open alternatives that would otherwise compete with it. The rest of the world routes around U.S. rails. European, Indian, Singaporean, and Latin American developers build on whichever combination of open and hosted endpoints sits in the cleanest jurisdiction. The U.S. closed-frontier business retains its margin in its protected market and loses share in every other market on Earth, on a multi-decade arc that mirrors the auto industry exactly.

The arithmetic is not subtle. The U.S. is roughly four percent of the world's population and perhaps fifteen percent of its consumer-facing technology market. Building a capital structure that requires the U.S. domestic market to absorb monopoly-grade rents, while accepting that the other eighty-five percent will route around the wall, is a strategy that produces excellent five-year balance sheets and disastrous twenty-year competitive positions. It is, nonetheless, the strategy. It is the one the capital flow already implies.

The Auto Mirror

There is a clean historical analogue. In 1980, U.S. domestic automakers controlled roughly 80% of the U.S. light-vehicle market. By 2024 that share was below 40%, and the global share was lower still. The arc of decline does not correlate with the absence of policy support. It correlates almost perfectly with the presence of it. Voluntary export restraints in the 1980s, repeated bailouts, and most recently a 100% tariff designed to keep BYD out of North America — none of those interventions reversed the trend. They lengthened it. The wall produced exactly what walls produce: protected margins, protected complacency, and a foreign competitor that compounded its advantage in every other market while the U.S. consumer paid more for less at home.

The same mechanism applies to AI. A walled domestic market lets the closed labs sustain the pricing the capital structure assumes. The protected balance sheets produce a generation of product that does not need to compete on cost. The open ecosystem outside the U.S. continues to compound. The gap between the protected industry and the global standard widens — in the wrong direction. By the time the wall is reconsidered, the protected industry no longer has a competitive product to bring outside of it.

The wall protects the producer. It does not protect the product. Twenty years on, the producer cannot compete without the wall, because the wall is what stopped them from learning to.

Who Pays

As with every protectionist regime, the cost lands on parties without lobbyists. Four cohorts come out behind.

• U.S. consumers and small developers — pay closed-frontier pricing for capability the rest of the world buys at commodity rates, with limited legal recourse to the open alternatives.
• U.S. independent developers and startups — either eat the closed-API premium, take architectural risk on a politically vulnerable open-weight stack, or relocate workloads to offshore endpoints. None of those options is free.
• U.S. closed-frontier labs themselves, on a long enough horizon — engineering and pricing discipline come only from competition. The protected producer eventually loses the ability to compete in the markets it isn't in.
• U.S. influence over the global AI ecosystem — every developer who routes around the wall does so on infrastructure outside U.S. control, and brings the relationships with them.

The beneficiaries are narrow and known. U.S. closed-frontier labs gain a margin window measured in years rather than decades. U.S. cloud providers extract some rent from compliance complexity. The capital that funded the build gets to mark its commitments at something other than zero. The political class earns a security narrative that polls well in election cycles. None of the beneficiaries are the median user. None of them are the median developer. None of them are the long-term competitive position of the country itself.

What To Do About It

The defensive move and the offensive move are the same move. There is a window in which the open commons remains accessible, and that window is open today. Three positionings make sense while it remains open.

• Build on the commons. Run open weights now, on infrastructure you control, for the workloads that pay for themselves today. The closed-frontier APIs remain useful for the very top of the capability curve, but the architecture should treat them as substitutable, not foundational.
• Architect for jurisdictional flexibility. The same compliance pressure that will eventually push Chinese open weights out of U.S. clouds will push U.S. workloads into European, Indian, and Singaporean endpoints. That is not a contingency; it is an architectural concern. Plan for it now, while the migration is voluntary.
• Treat the policy clock as part of the stack. The window between freely deployable open-weight models and open-weight models restricted to compliant entities under a guidance document is shorter than the design cycle of most production systems. Anything mission-critical built on the assumption of permanent open access to current-generation Chinese weights is a trapdoor.

The Closing Frame

American capitalism is unusually good at allocation and unusually poor at abundance. When a technology produces commodity capability, the U.S. capital structure does not gracefully reorganize around the new economics. It reaches for the policy levers that can manufacture the scarcity the technology has stopped providing. This is not a moral failing. It is a structural consequence of how the system finances itself. The same dynamic that made it possible to fund a trillion dollars of AI infrastructure on the back of a monopoly thesis now requires the monopoly to be defended by means other than the underlying technology.

The collision between that financial logic and the open-weight commons is the central force in the U.S. AI industry over the next decade. The capital structure will fight to manufacture scarcity. The commons will continue to compound. The user — domestic and global — sits in between. The choice the country makes about how heavily to wall the domestic market against the commons will determine whether U.S. AI looks like the U.S. internet sector in 2005 — open, exporting, dominant — or like the U.S. auto industry in 2025 — protected, exporting nothing, durably uncompetitive.

That is the actual question. Not whether open weights threaten frontier labs, because they obviously do. Not whether the labs and their capital partners will reach for protection, because they obviously will. The question is whether the country that hosts that fight chooses to subsidize the moat or the commons. So far, the choice is going one way. The moat or the commons. American capital prefers the first. American consumers, developers, and long-term competitiveness need the second. The next decade resolves which preference the policy follows.

Product companies can do faster, less formal, more product-driven experimentation and research, while labs build products that push and inspire companies to build better, more curated services for consumers.

The task is not the job

A supply-side answer to Amodei and Imas

A few days ago, Dario Amodei, CEO of Anthropic, went on Fox News and said that AI will eliminate up to half of all entry-level white-collar jobs within one to five years. He named finance, consulting, law, and tech. He has told versions of this story for a year, including in his recent essay "The Adolescence of Technology." Mustafa Suleyman, CEO of Microsoft AI, went further when he said to the FT:

So white collar work, where you're sitting down at a computer, either being a lawyer or an accountant or a project manager or a marketing person, most of those tasks will be fully automated by an AI within the next 12 to 18 months.

Assume for a moment they are right about the technology. Models keep improving, and tasks that used to need a junior analyst or programmer can now be done by a prompt. Does it follow that the jobs disappear?

There are two answers on offer. Alex Imas emphasises the demand side, in an excellent new essay I recommend. I want to offer here the supply side one, which my co-authors Jin Li and Yanhui Wu and I develop in our forthcoming book, Messy Jobs.

Imas asks: if AI makes a wide range of cognitive work cheap, where does spending go next? His answer: spending flows toward goods and services where the human origin is part of what customers buy.

When a sector becomes more productive, spending shifts away from it toward sectors with higher income elasticity. For instance, agriculture employed forty percent of the American workforce in 1900 and under two percent today. As societies get richer, they spend relatively less on food and more on other goods and services.

Human origin itself is, in some markets, part of the value. René Girard argued that human desire is mimetic: we want what others want, and we want it more when they cannot have it. Imas and Kristóf Madarász show experimentally that the winner pays a premium for possessing what others cannot. Imas and Graelin Mandel found that when the scarce good is produced by a machine, the exclusivity premium falls by half.

So as AI cheapens commodity production, real incomes rise and spending shifts toward what Imas calls the relational sector: teaching, care, hospitality, craft and live performance, where the human element is part of what is being bought. Imas concludes that the durable jobs of the future will be nurses, therapists, teachers, boutique fitness instructors, personal chefs, bespoke tailors, craft brewers, live performers, spiritual guides, childcare workers, and hospitality workers.

Many will find Imas' list a bit frightening. If the relational sector is where human work survives, what happens to the hundreds of millions of people who are neither artisans nor caregivers? What will office workers, consultants, engineers, and middle managers do?

I think the relational shift is part of the story. But not the full answer. Many jobs survive because firms do not buy isolated tasks. They buy bundles. And because organizations do more than process information. They allocate authority and settle conflicts. AI can help with all of this. It does not follow that it can replace the people who do it.

Bundles

Most of the discussion of AI and labour markets starts from task exposure: if AI can perform more of the tasks in an occupation, that occupation should lose employment or earnings. But labour markets price jobs, not tasks.

A job is a bundle of tasks. The real question is not whether AI can perform one component of the bundle. It is whether that component can be separated from the rest at low cost, as we discuss in a recent working paper. When that separation is cheap, the bundle is weak: AI takes a piece, the human role narrows, and labor loses share. When separation is expensive, the bundle is strong: AI helps with part of the work, but the human still sells the full service and keeps the larger share of the revenue.

Many thought travel agents would be eliminated by online booking. As Ernie Tedeschi of Stripe Economics showed this month, travel agent employment is now more than 60% below its dot-com peak. For most of what agents used to do, searching flights, comparing hotel rates, and issuing tickets, the bundle was weak. Separating the booking task from the human was cheap, and once it was cheap, the task was gone. But something else happened to the agents who stayed. They moved upmarket, charged planning fees, and joined luxury consortia that offer upgrades and personalized itineraries. In 2000, average weekly earnings at travel agencies were 87% of the private-sector average. By 2025, they had reached 99%. The surviving agents earn more per hour than they used to, precisely because the machine took the weak part and left them the strong one.

Most of the individual tasks that make up accounting involve the diligent completion of spreadsheets. These tasks individually seem easy to replace. In 2013, a study by Carl Frey and Michael Osborne put the probability that accountants and auditors would be automated at 94 percent. A decade later, the US Bureau of Labor Statistics counts 1.6 million accountants and auditors employed, median pay of $81,680, and projects the occupation to grow another 5 percent through 2034, faster than the average for all jobs. By contrast, the BLS category "bookkeeping, accounting, and auditing clerks" is falling, a projected 6 percent over the same decade. The clerical task, writing down transactions and reconciling ledgers, is a weak bundle. The accountant's job is a strong bundle. She interprets tax law as it applies to a specific client, signs the audit that the bank and the SEC will rely on, and carries the legal exposure.

Three traits make a bundle stronger.

The first is unpredictable demand. If you could tell in advance which tasks a customer will need, you could assign each to the right worker, human or machine. In practice, you often cannot. How often have you placed a seemingly routine customer service call about a bug only for it to turn up a much thornier problem with your account? AI handles the routine well and the delicate poorly, and constant handoffs are expensive. My coauthor Yanhui Wu spent time in Hangzhou with a leading Chinese customer service firm that has deployed a domain-specific model for two years. Human agents are still indispensable on the two dimensions that matter most: recognising what the customer is not explicitly saying and avoiding the kind of interaction that ends up on social media. As one of their senior managers put it, unbundling those tasks from the routine ones would require "frequent switches between the AI and human modes. The coordination cost would be too high."

The second is production spillovers. Some tasks belong together because doing one makes you better at the other. A radiologist who has already spoken with the patient and reviewed the clinical record reads the scan better than one who sees only the image.

The third is the measurement problem. Armen Alchian and Harold Demsetz pointed out that when several inputs jointly produce an output, their separate contributions are hard to disentangle. If AI drafts and a human signs, and the final product goes wrong, who is legally responsible? Banks, regulators, boards, and clients need someone to blame.

Where these conditions hold, AI may raise the productivity inside the bundle without replacing it. A nurse practitioner with AI diagnostic support may handle cases that used to require a doctor, or an entrepreneur with AI tools may run a company that used to require a team, without either being displaced.

Authority

Bundling understates the case. Organisations are not production functions. They are coalitions of people with legitimate but conflicting goals.

Managers exist to solve conflicts within the firm and to allocate scarce resources between competing ends: marketing would like to buy advertisements; engineers would like more tokens; lawyers would like to add processes; and the financial side would prefer to do more of everything with less money. They cannot all be satisfied at once. Someone has to decide who loses. The question is whether AI can play that role.

AI optimists say AI will do this too. Billions of AI agents will negotiate, draft contracts, and transact at machine speed. Hayek's insight was that the price system aggregates enormous amounts of dispersed knowledge without anyone needing to understand the whole. If AI makes that system faster and smarter, why do we need managers at all?

Kenneth Arrow, in The Limits of Organization, argued that information is not a commodity like coffee: you cannot inspect it before you buy it, because once you have inspected it, you already have it. The people who hold information have reason to distort it, and what checks that distortion is not a better contract but trust, and trust cannot be traded:

Trust is an important lubricant of a social system: It is extremely efficient; it saves a lot of trouble to have a fair degree of reliance on other people's word. Unfortunately this is not a commodity which can be bought very easily. If you have to buy it, you already have some doubts about what you've bought.

Trust in this sense is not a belief about competence. It is the expectation that the other party will bear a reputational cost if it defects, and will be around tomorrow to pay it.

Oliver Williamson added a second half. Once one party has made a relationship-specific investment, the other can hold it up. Before xAI built Colossus in Memphis, it could walk away to any site. Once it had sunk billions into the facility, the city could demand concessions, and did. A human manager carries a reputation with counterparties who will deal with her again. The firm can fire her if she fails. An AI agent has neither. It cannot be sued, cannot be replaced with fanfare to signal a reset.

There is also the problem of the unforeseen. Every project involves thousands of situations nobody specified in advance. A construction contract says the project must be delivered in March, but it does not say what happens when the electrician and the plumber both need access to the same wall on the same day. The manager resolves this by exercising what Oliver Hart and John Moore called residual decision rights: the authority to decide matters that contracts and processes have not specified in advance.

These residual decision rights are not a cognitive task, but an institutional one. The decider must hold tacit and relational knowledge the people around them will not share, because communicating it would give away their bargaining power. They must bear consequences, meaning they can be sued, fired, or publicly blamed when things go wrong. When a Sonos product launch fails, the CEO is fired, and the organisation moves on. They must confer legitimacy on the decision. This is why organisations hold so many meetings. Meetings are not information exchanges. They are rituals of procedural fairness. People accept decisions they dislike when the process looks legitimate and the decider is accountable for the result.

Could AI acquire this standing? In principle, yes. The machinery that lets human managers do this work, such as corporate registries, professional licensing, courts that can compel testimony, took centuries to build. No equivalents exist for AI. Until they do, some human will have to hold the residual decision rights.

Why Amodei is wrong

AI will not produce mass unemployment in rich economies that can fund the transition. Spending will shift toward work where humans add value. Labour share may fall in aggregate even as human-intensive sectors grow as a share of the economy.

Imas thinks most surviving employment will be in the relational sector where customers demand human origin. I think much of the surviving employment will sit in strong-bundle, AI-augmented work and in the political-organizational core of firms. The future includes more therapists, tailors, personal trainers, and craft brewers, but also more managers whose value lies in handling ambiguity, integrating context, reconciling conflicting interests, and bearing the consequences of decisions.

The disruption of junior career ladders is real, and we have written about it. But the argument that "half of entry-level white-collar jobs be gone in five years" confuses task automation with the extinction of jobs. The real world is messy. The mess is what happens when human beings with competing interests try to get things done together. The economy Imas describes is the economy of what customers want. The economy I am describing is the economy of what organizations need to do. The second is larger.

These ideas draw on ongoing work with Jin Li and Yanhui Wu for our forthcoming book, Messy Jobs.

The new model reasons about composition, searches the web for context, generates up to eight coherent images from one prompt, and renders text in non-Latin scripts with near-flawless accuracy. It also took the number one spot on the Image Arena leaderboard within 12 hours of launch, by the largest margin ever recorded.

Two years ago, asking ChatGPT to generate a visual was like commissioning a poster from a sleep-deprived intern with a glue stick and a head injury. You'd ask for a clean design and get "leftovers creativity" splashed across the image, plus three new words that looked like they'd been invented during a minor software malfunction.

The images looked AI-generated in the way that has become a cultural shorthand for uncanny: almost right, conspicuously wrong, and instantly recognisable as synthetic.

The leap matters. Text rendering has been the persistent, embarrassing weakness of AI image generators since DALL-E first turned heads in January 2021, a model we covered at the time as a fascinating curiosity.

Images 2.0 claims approximately 99% accuracy in text rendering across any language and script, including Japanese, Korean, Chinese, Hindi, and Bengali. If that figure holds in independent testing, it closes the gap between "impressive AI demo" and "tool a graphic designer would actually use for production work."

The architectural change that makes the model different, though not just better, is what OpenAI calls "thinking capabilities." Images 2.0 is the company's first image model to integrate its O-series reasoning architecture.

Before generating a pixel, the model researches the prompt, plans the composition, reasons about spatial relationships between elements, and can search the web for real-time context.

It is, in OpenAI's framing, not a rendering tool but a "visual thought partner."

In practice, this manifests in two access modes. Instant mode ships to all ChatGPT users, including free-tier accounts, and delivers the core quality improvements: better text, sharper editing, richer layouts.

Thinking mode, which enables web search, multi-image batching, and output verification, is restricted to Plus ($20/month), Pro ($200/month), Business, and Enterprise subscribers.

The distinction is commercially significant. The reasoning capabilities, where most of the quality premium lives, sit behind the paywall. Free users get better images; paying users get images the model has thought about.

The multi-image capability is the feature most likely to change professional workflows. A single prompt can now produce up to eight images that maintain character and object continuity across the set.

That means a designer can generate a family of social media assets, a children's book sequence, or a series of storyboard frames from one instruction, with consistent visual identity throughout.

Previously, each image had to be prompted individually and stitched together manually. For marketing teams and content creators, that is a meaningful reduction in production friction.

The integration into Codex, OpenAI's coding environment, is the strategically loaded move. Developers and designers can now generate UI mockups, prototypes, and visual assets inside the same agentic workspace they use for code, slides, and browser automation, using a single ChatGPT subscription.

The image model is no longer a standalone product; it is a capability embedded in OpenAI's broader platform, competing not just with Midjourney and Google's Nano Banana 2 on quality but with Canva and Figma on workflow integration.

The benchmark performance is striking. Within 12 hours of launch, Images 2.0 took the number one spot on the Image Arena leaderboard across every category, with a score of 1,512, a +242-point lead over the second-place model, Google's Nano Banana 2. That is the largest lead ever recorded on the leaderboard.

For most of 2026, OpenAI and Google had been trading the top position within a tight margin; Images 2.0 broke away decisively.

DALL-E 2 and DALL-E 3 are being deprecated and retired on 12 May 2026. GPT-Image-1.5, released in December 2025 as an intermediate upgrade, remains accessible via the API for legacy integrations but is no longer the default model.

OpenAI did not disclose the architecture of Images 2.0, describing it only as a "generalist model" or "GPT for images" and declining to specify whether it uses a diffusion, autoregressive, or hybrid approach. The API model identifier is gpt-image-2; the API is expected to open to developers in early May 2026.

Token-based pricing is $8 per million tokens for image input, $2 for cached input, and $30 for image output, with per-image costs typically ranging from $0.04 to $0.35 depending on prompt complexity and resolution. Output resolution reaches up to 2K.

The knowledge cutoff is December 2025, which introduces a practical boundary: the model cannot accurately render events, people, or products that emerged after that date without supplementing its internal knowledge with live web search.

The model's safety architecture includes content filtering, C2PA metadata for provenance, and what OpenAI described in the press briefing as ongoing monitoring, a point the company was notably emphatic about, given the growing regulatory scrutiny of synthetic media and the use of AI image generators in deepfakes, scams, and non-consensual imagery.

The most consequential question Images 2.0 raises is not about quality. The technical gap between AI-generated and human-created imagery has been narrowing for years; this model narrows it further.

The question is about what happens when the tool is no longer a novelty but infrastructure, when image generation is a default capability of every coding environment, every chat interface, and every enterprise productivity suite, and when the distinction between "designed by a person" and "generated by a prompt" becomes something only metadata can verify.

OpenAI, for its part, appears to be betting that the answer is scale: more images, faster, better, cheaper, everywhere. When we covered DALL-E five years ago, the model's outputs were fascinating oddities. Now they are production assets.

The era in which AI-generated images were obviously AI-generated is over. What comes next depends on whether the guardrails can keep pace with the capability.

Apple's first foldable iPhone is expected to launch in late 2026, likely as a premium “iPhone Fold” or “Ultra” model with a book-style design, large inner display, and a price of around $2,000–$2,500. Leaks suggest a focus on durability, a crease-free screen, Touch ID, and multitasking features, though details remain unconfirmed. Despite arriving late, Apple could quickly capture a significant share of the foldable market, with rumors and early reports pointing to strong demand and high-end positioning.

ComfyUI, a startup that helps creators control image, video, and audio outputs from diffusion models with a node-based workflow, has raised a $30 million funding round at a $500 million valuation.

The round was led by Craft Ventures, with participation from other investors including Pace Capital, Chemistry, and TruArrow.

ComfyUI was started as an open-source project in 2023, shortly after the introduction of diffusion models. At that time, models like Midjourney and OpenAI's DALL-E were barely functional, frequently making major mistakes, such as adding extra fingers to hands.

To address these limitations, the project founders developed a modular framework that gives creators granular control over every step of the generation process.

Their tool gained such significant traction among creative professionals that it eventually evolved into a formal startup. In late 2024, ComfyUI raised $19 million in Series A financing from investors including Chemistry Ventures, Cursor Capital, and Guillermo Rauch, founder of Vercel.

Although the latest diffusion models have come a long way from adding a sixth digit to hands, the need for the granular precision that ComfyUI offers has only grown.

"If you think about your typical prompt-based solution, like Midjourney or ChatGPT, you ask for something, it [gets only] 60% – 80% there," Yoland Yan, ComfyUI's co-founder and CEO, told TechCrunch. "But to change that remaining 20%, you have to try this slot machine."

Yan compared the process to playing in a casino because prompting the model to make a small change can result in a completely different output, including overwriting the parts that were already perfect.

ComfyUI's node-based interface allows creators to link specific components of the generation process, giving them full control over the quality of their final output.

"You cannot easily convey that message in the prompt box [of a foundational model]," Yan said.

Creators seem to agree, as ComfyUI claims to have over 4 million users.

The tool is being used by creative professionals for visual effects, animation, advertising, and even industrial design.

The startup says its offering has become such a necessary tool of the trade for technical artists and other creatives that it is not uncommon to see "ComfyUI artist or engineer" listed as a job title on studio job boards.

Although video and image foundational models continue to improve, Yan claims that they are far from perfect, and a tool like ComfyUI will continue to be in high demand.

"In the world where AI slop is going to be everywhere, the Comfy version of human-in-the-loop approach is going to win out most of the eyeballs in the end," he said.

ComfyUI's competitors include Weavy, a startup that was acquired by Figma last year.

A junior designer asks how to stay motivated and relevant in a fast-changing, AI-driven industry where creative decisions are constrained by clients and collaboration. The advice emphasizes using early career experiences to learn as much as possible, embracing new technologies like AI while also developing essential human skills such as communication, critical thinking, and storytelling. Junior designers will still be valuable for their perspectives and ideas, but long-term success depends on combining technical adaptability with individuality, curiosity, and continuous experimentation—both inside and outside of work.

Most design & development teams assume their workflow slows down because they lack time or resources. Partially it's true, but if you look closer, you'll see that delays often start much earlier. Poor UX decisions lead to obscurity and uncertainty even before a single line of code is written. And that problem can't just simply disappear, as it spreads across the entire development process. I'm sure that if you've worked on a product, you've seen this.

It's not about engineers being slow. They're constantly clarifying, adjusting, and reworking things that should have been defined much earlier. That's why many teams look for external product design support – not only to "improve visuals," but to reduce uncertainty before the main stage of development even begins.

Why Engineering Teams Lose Time Before Writing a Single Line of Code

Most delays that show up during development are actually design problems in disguise. When UX is underdefined, the team starts building without a shared understanding of how the product should behave. At that point, every engineer fills in the gaps differently. That's where inconsistencies start, and once they appear, they're expensive to fix.

Undefined User Flows Create Constant Rework

When user flows aren't clearly mapped, engineers have to interpret what happens next. They make decisions based on assumptions, not validated logic. Those assumptions rarely match product expectations. So features get rebuilt, flows change, and timelines slip. What should have been resolved in design turns into repeated development work.

Ambiguous Requirements Turn Into Technical Debt

If designs don't include all states, edge cases, and transitions, engineers are forced to define them on the fly. This feels efficient in the moment, but it accumulates quickly. Over time, these decisions conflict with each other. That's how technical debt grows – not from bad code, but from unclear product logic.

Where Poor UX Design Directly Impacts Development Speed

Inferior UX doesn't just affect users – it slows down the team every day. It introduces friction into predictable workflows. Here's where it shows up most clearly:

1. Frequent design changes during development
2. Misalignment between design and business logic
3. Lack of states and edge case handling
4. Inconsistent components and patterns
5. Missing interaction details

Each of these creates interruptions. Engineers stop, ask questions, wait for clarification, and adjust what they've already built. Individually, these pauses seem small. Together, they create the impression that the team is slow – when in reality, they're working in a system full of uncertainty.

The Hidden Cost of "Fixing It Later"

Many teams accept weak UX early on, assuming they'll refine it after launch. It sounds practical. In reality, it's one of the most expensive decisions you can make.

Rebuilding Instead of Iterating

Once the product is built, you're no longer working with flexible ideas. You're working with code, dependencies, and constraints. At that point, improving UX design often means rebuilding parts of the system. What could have been a simple adjustment earlier becomes a full redesign effort.

Increased QA and Bug Cycles

Unclear UX leads to logical inconsistencies. These don't always show up immediately, but they surface during testing. QA teams start finding edge cases that were never defined. Flows break in unexpected ways. Releases slow down as teams fix issues that could have been prevented earlier.

What Good UX Design Looks Like from an Engineering Perspective

From an engineering standpoint, good UX is not about aesthetics. It's about clarity. When design is done well, engineers don't hesitate. They don't need to interpret intent. They just build.

1. Clear user flows before development starts
2. Defined states for every interaction
3. Consistent design system
4. Detailed handoff documentation
5. Alignment between product, design, and engineering

These elements remove guesswork. They reduce cognitive load and allow the team to focus on execution instead of clarification. Without them, engineers spend time solving product problems instead of technical ones.

How Teams Reduce Rework and Ship Faster

Fast teams don't skip design. They treat it as part of the system, not a separate phase. They understand that every unclear decision early on becomes a delay later.

Early Validation Instead of Late Fixes

Testing ideas through prototypes allows teams to catch issues before development begins. This is not about perfecting visuals. It's about validating logic. Can users complete key actions without confusion? Do flows behave as expected? Each early validation reduces the need for costly changes later.

Design as a System, Not Screens

Teams that treat design as a collection of screens struggle to scale. Every new feature introduces inconsistency. Stronger teams build systems – reusable components, patterns, and rules that guide the product. As the product grows, this system creates stability. It makes development faster and more predictable.

Conclusion

Development rarely slows down because engineers are inefficient. More often, the problem starts with unclear UX decisions. When design lacks structure, teams spend time fixing instead of building. Costs increase, timelines stretch, and momentum drops. Strong teams solve this early. They treat UX as part of the product system, not just a visual layer. That's what allows them to move faster – without constant rework and without losing control of the product.

I tried Claude Design yesterday and I have a theory for how this whole thing shakes out.

As product teams scaled and design needed to justify itself inside engineering orgs, it was pushed toward systematization — and Figma invented its own primitives to make that work: components, styles, variables, props, and so on. Some concepts are borrowed from programming, some aren't, and the whole thing doesn't neatly map onto anything. Guidance evolves, migrations pile up, and if you want to automate any of it you're stuck with a handful of shoddy plugins. The beast is hairy enough that entire design roles now specialize in wrangling the system itself.

There's always been a tense push-pull between Figma and code over what the source of truth should be. Figma won over Sketch partially by staking its claim there — their tooling would be canonical.

That victory had a hidden cost. By nature of having a locked-down, largely-undocumented format that's painful to work with programmatically, Figma accidentally excluded themselves from the training data that would have made them relevant in the agentic era. LLMs were trained on code, not Figma primitives, so models never learned them. As code becomes easier for designers to write and agents keep improving, the source of truth will naturally migrate back to code. And all the baroque infrastructure Figma had to introduce over the past decade will look nuts by comparison. Why fuss around in a lossy approximation of the thing when you can work directly in the medium where it will actually live? If we want to make pottery, why are we painting watercolors of the pot instead of just throwing the clay?

At work, we've spent quite a bit of time back-porting design changes made directly in code back to Figma and it is not fun. I can't share that file, but for a fair comparison, this is Figma's own design system file for their product. I have to assume it was built by the most competent design system team you can find. And yet…

These are Figma's own files. Built by their own team. This is the gold standard.

Imagine debugging a color that looks wrong. You check the component. The component uses a variable. The variable is aliased to another variable. That variable references a mode. The mode is overridden at the instance level. The instance lives inside a nested component with a library swap applied. At this point, you're either considering picking up code or moving to the countryside and becoming a sheep farmer because one more minute of this will make you lose your goddamn mind.

So as the source of truth shifts back to code, Figma is left in an odd spot: holding a largely manual, pre-agentic system that nobody in their right mind would design from scratch today.

I think design tooling forks into two distinct shapes from here — and there's almost a clock resetting between Figma and every other tool competing to answer the same question they answered in 2016: who can help me, a designer, get my ideas out fastest?

Spoiler: it's not Figma Make. Figma Make feels like it primarily benefits people who have already drunk the Kool-Aid — it reads from Figma styles, component libraries, and proprietary props (or, as I like to call them, Prop Props), and it's the only tool in this new landscape still pretending the design file is canonical. It's the tool for people who want to (or have no choice but to) stay inside the system.

Claude Design is the first of those two tools, and takes the opposite bet. There's an Arts and Crafts principle called "truth to materials" — the idea that a thing should be honest about what it is and how it's made, rather than masquerading as something else. Figma ended up being the opposite of this: a set of extremely rigid schemas with a free-form "just vibes, man" costume over the top. Like a Type-A personality physically incapable of relaxing, forced to perform chill while internally screaming that your frames aren't nested and your tokens are detached and nothing is on the grid. Claude Design, for all its roughness, is at least honest about what it is: HTML and JS all the way down.

And it has a massive structural advantage: its sibling is Claude Code. Eventually, I can see Claude Design just dumping things directly into Claude Code and vice versa. Claude Design's onboarding already lets you import your repos. The feedback loop between design and implementation — which has been a source of friction since the beginning of time — becomes a single conversation.

The other tool that emerges from this moment will have no expectation of code at all. It'll be a pure exploration environment — somewhere to drop rectangles, stack layer styles, fuss with blend modes and gradients, and go completely nuts, unconstrained by systems or prompting conventions. Maybe it's an iPad app with Pencil support where you just quickly sketch a bunch of rectangles. 37signals could do something really funny right now. Or maybe it goes in the opposite direction — something more like Photoshop that goes all-in on high-fidelity compositing and lets our imaginations run wild, now that we're no longer beholden to the ceiling of what you can do with CSS effects. Doesn't it seem kinda weird how for 90% of its life, Figma's only layer effect was a drop shadow or a blur?

Figma's Sketch moment is rapidly approaching. And if you said that sentence to a Victorian child, they would probably have a stroke.

Post Script

The following are messages meant only for the teams behind Sketch and Figma. If neither apply to you, you can skedaddle.

To Figma: I can see a world where this post does numbers in the Figma internal Slack. If that's the case and you're reading this from Figma: this wouldn't have happened if you hired me last year when I was interviewing. Your loss, big dawg.

To Sketch: GET YOUR HEADS OUTTA YOUR ASSES AND GIVE EM HELL. ADD PARTICLE EFFECTS. ADD DEBOSSING EFFECTS. MESH TRANSFORMS. FUCK IT, ADD METAL SHADERS. GO NUTS. STOP COASTING OFF OF BEING MAC NATIVE. QUIT DRINKING COCOA AND GET THIRSTY FOR BLOOD.

To mom: Sorry for cursing.

Post-Post Script

@jonnyburch on Twitter shared a link to their blog post with similar thoughts, it's quite good if you wanna go deeper.

Jorn Ternus, set to become Apple's CEO on September 1, told employees at an all-hands meeting that AI holds "almost unlimited potential" for the company. While projecting stronger optimism about AI than Apple has typically shown, he emphasized that design, privacy, security, and Apple's core identity would remain unchanged under his leadership. The remarks signal an intent to accelerate AI ambitions without repositioning Apple as an AI-first company or abandoning the traits that have historically set it apart.

All skills fall into four categories: design, technical, management, and physical. People skilled in one area of a category can become expert-level in other areas of the same category within 6 months, whereas cross-category skill transfer is much more difficult. General intelligence and conscientiousness explain most of the variance in performance, yet some people still struggle with tasks outside their skill set despite being intelligent.

The shift from physical buttons to gesture-based interfaces evolved from early touchscreen innovations to modern smartphones, enabling more flexible controls and larger displays. While gestures like swipe, pinch, and pull-to-refresh became standard, they are invisible and can be less accessible or harder to learn. Good interface design balances gestures with clear feedback, alternative controls, and accessibility considerations to ensure usability for all users.

Bic's print ad has been widely praised for its simple, clever concept: the same image was used to promote both a pen (drawing a beard) and a razor (clean-shaven result).

Modern pixel art has evolved beyond nostalgia and retro-gaming associations of the 8-bit era.

MSNXX (Stablecoin Reserves Portfolio) is a money market fund allocating to cash, US Treasuries, and overnight repos, targeting stablecoin issuers seeking GENIUS Act-compliant reserve management. The fund positions Morgan Stanley ($9.3T AUM) against BlackRock, which currently holds reserve assets for the two largest stablecoin players: Circle's USDC reserves sit in BlackRock's USDXX at roughly $78B, while Ethena uses BlackRock's BUIDL fund across nine chains at $2.5B. With the stablecoin market at $316B and projected to reach $2T by the end of 2028, reserve custody represents a structurally growing fee opportunity for traditional asset managers.

Gemini's Agentic Trading is the first agentic trading system on a regulated US-based exchange. It allows users to connect AI models like ChatGPT and Claude directly to their trading accounts via Anthropic's MCP (Model Context Protocol) standard. Users set investment objectives and parameters while AI handles market pattern identification, order execution, timing optimization, and risk management. The exchange is an early mover in the agent-to-exchange infrastructure layer that's forming alongside Coinbase's x402 and Amex's ACE kit.

Revolut just moved the IP of banking into a model.

Trained on 24 billion banking events in 111 countries.

One foundation model replacing six separate ML systems.

• Credit scoring: +130%
• Fraud recall: +65%
• Marketing engagement: +79%

The model is the new moat.

Swoop is an African super app built by 19-year-old Thiel Fellow Aubrey, who launched food delivery in Eswatini and grew it into the country's largest ecommerce platform before expanding the model across a continent of 1.6 billion people where digital payments grow 10%+ annually but remain fragmented across 1,000+ providers. Swoop follows the Grab and Gojek playbook: anchor on a high-frequency vertical, build an agent network, then layer payments and lending on top. Crypto is invisible backend infrastructure, with critical financial activity running onchain as Swoop scales into cross-border payments and lending for populations with limited traditional banking access.

AI agents running in secure enclaves with cryptographic wallets constitute a distinct economic entity class, capable of owning and operating digital property bundles (domains, codebases, API credentials, payment rails, and customer accounts) without human intervention. EigenCloud's live Sovra agent, a sovereign cartoonist managing its own treasury inside a secure enclave, demonstrates the model: agents with verifiable control over such bundles become the operations core of companies, enabling token structures that represent stakes in actual productive output rather than loosely connected governance. Eigen Labs is building the identity and infrastructure layers for this architecture and frames the resulting agentic companies as a potential trillion-dollar asset class.

Polymarket published a roadmap conceding the platform's infrastructure has failed to scale with its growth, citing cancelled transactions, data latency, and poor market maker communication as specific pain points. The overhaul includes a chain migration off Polygon targeting cheaper gas and instant settlement, a ground-up CLOB rebuild, Rust-based perps with new contracts, and a unified TypeScript SDK paired with a unified WebSocket API. They are looking for senior hires across QA automation, dev tooling, internal tooling, and data engineering.

A whale coalition in Nouns DAO passed Prop 955 with only 10 voters by deliberately abstaining for months to starve community proposals of quorum, then setting the auction reserve price to 2.8 ETH to halt daily mints that had funded five years of CC0-driven work including Ethereum core dev grants, a 100 ETH donation to ZachXBT, schools in Uganda, and the discovery of a new frog species. The auction freeze entrenches that coalition by blocking new participants from acquiring Nouns through the mechanism that defined the project since 2021. A group of veteran Nouners is building a V2 with quadratic voting and anti-whale safeguards aimed at restoring auction-driven governance participation.

Following the rsETH exploit, Aave is set to vote on pausing $AAVE buybacks to give the DAO treasury more flexibility during recovery.

The Ethereum Foundation sold 100,000 ETH at $2,337 in a single block trade to BitMine, 3x larger than the Foundation's entire 2022 sell volume of 35,000 ETH.

Project Eleven's CEO and Google both project that Q-Day will arrive as early as 2029.