Full article content is not available for inline reading.

Read the original article →

Full article content is not available for inline reading.

Read the original article →

Push-based KV transfer to improve TTFT and TPOT for disaggregated inference in vLLM

vLLM is an open-source inference and serving engine for large language models (LLMs). LLM inference has two distinct phases: prefill, which processes the input prompt and builds the key-value (KV) cache, and decode, which uses that cache to generate output one token at a time. These phases have different compute, memory, and scaling characteristics. Prefill-decode (P-D) disaggregation runs them on separate engine instances, allowing each phase to scale and be optimized independently. This can improve resource utilization, throughput, and latency under load. However, it also requires transferring the KV cache from the prefill instance to the decode instance before token generation can begin, making efficient KV transfer critical to time-to-first-token (TTFT).

One of the ways vLLM performs this transfer is through the NVIDIA Inference Xfer Library (NIXL) connector, which moves KV blocks over interconnects that support Remote Direct Memory Access (RDMA), such as AWS Elastic Fabric Adapter (AWS EFA, the low-latency RDMA network used across servers in AWS). On supported instance types, AWS EFA supports GPUDirect RDMA and Neuron Direct RDMA. NIXL can therefore transfer KV blocks directly between GPU or AWS Trainium device memory without staging through host memory. The default mode for NIXL connector is pull-based: After the prefill instance finishes computing the prompt KV cache, the router relays the source metadata, including the prefill block IDs, to the decode instance. The decode instance then allocates destination blocks, prepares the NIXL transfer, and initiates NIXL READ to pull the KV blocks from the prefill instance. Because these coordination and setup steps occur sequentially after prefill and before decoding can begin, they extend the TTFT critical path, as shown in the following timeline.

Figure 1: Pull-mode KV transfer timeline, where the router relay, decode-side allocation, and NIXL READ run serially on the path to the first token

This post introduces a push-based NIXL connector that moves post-prefill transfer coordination and setup off the critical path. If you run disaggregated prefill/decode inference with vLLM, push mode can improve application responsiveness by reducing TTFT and TPOT, particularly at high request rates.

In our benchmark on a 1P1D deployment using Amazon Elastic Compute Cloud (Amazon EC2) P5en instances connected with EFA, push mode delivered up to 3x better TTFT and up to 30 percent better time-per-output-token (TPOT) compared to pull mode (see the Performance data section) for the Qwen3-32B model. Results depend on workload and configuration.

We built and validated the feature on AWS Trainium instance clusters connected with EFA, and then we contributed it to vLLM as an accelerator-agnostic feature. The results here are from an Amazon EC2 P5en (GPU) cluster with EFA, showing the gains carry over to GPUs. This post explains the push-based architecture, transfer flow, threading model, performance results, and how to reproduce the benchmark.

Push-based KV transfer

This section explains the push-based design: its architecture, the transfer protocol, and the threading model that keeps KV transfer off the critical path.

Architecture overview

Push-based transfer improves TTFT and decode throughput for two reasons:

• It removes the serialization of the pull model by overlapping producer and consumer work. The decode instance registers its target blocks in advance while the producer is still computing KV. The transfer then begins as soon as the producer’s blocks are ready, rather than after a consumer-side ID-discovery round trip, removing that round trip from the path to first token.
• It moves the transfer-setup time off the decode instance. That setup runs on the prefill side and on a background thread. It prepares the NIXL descriptors and submits the transfer, so the decode instance does not spend those cycles during its latency-critical token-generation phase.

The net effect is lower TTFT and higher output-token throughput on the decode instance.

The push connector coordinates three actors: the decode instance registers its target blocks up front, the prefill instance matches each request and issues the transfer, and a dedicated background thread carries the KV write off the engine’s forward-pass loop. The following diagram shows how these pieces fit together.

Figure 2: Push-based KV transfer architecture, showing how the decode instance, prefill instance, and background transfer thread coordinate

Implementation details

The protocol has three logical steps.

1. Registration (decode side). When the decode instance allocates local blocks for a request requiring remote prefilling, it prepares a registration describing where the prefill instance should write the KV: its own identity and the block locations it has just reserved. Within the same engine step, the worker transmits this registration to the prefill instance as a NIXL notification. Because registration happens at allocation time, the connector knows the destination blocks before the prefill instance completes prefill.

2. Rendezvous (prefill side). The registration from the decoder and the completion of prefill on the producer can arrive in either order, and the connector handles both. If the registration arrives first, the producer holds it until its own prefill finishes. If prefill finishes first, the producer holds the request’s blocks until the registration arrives. Whichever event happens second triggers the transfer. The connector pairs requests by ID, and the matching accounts for reissued requests, correctly associating preempted or retried requests.

3. Transfer (prefill side). Once a request is matched, the producer establishes a connection to the decode instance (if one does not already exist) and issues an NIXL WRITE that copies the KV blocks directly into the decoder’s registered memory, addressing each destination tensor-parallel rank. The producer and consumer may use different internal block layouts. Each side maps block locations to its own physical layout at transfer time, allowing different block sizes on each side. Each WRITE carries a completion notification that NIXL delivers to the decode instance once the data arrives. The decoder counts these notifications, one per producer rank that writes into it. It treats the KV as received only after all expected notifications have arrived, at which point the request proceeds to decode.

Threading model

The push connector separates model execution from KV-transfer preparation by using a dedicated background transfer thread on each prefill worker. At the start of a request, the decode main loop allocates its destination KV blocks and registers them with the prefill instance while the prefill main loop computes the prompt KV cache. After both the destination registration and prompt KV are ready, the prefill main loop hands the KV blocks to the background thread and quickly returns to model execution.

The background thread establishes or reuses the NIXL connection, maps the request’s KV block IDs to memory descriptors, merges contiguous blocks into larger transfer regions, and submits the NIXL WRITE to the decode instance. When NIXL completes the transfer, it sends a completion notification to the decode instance, which then begins token generation. Keeping descriptor preparation and transfer submission off the latency-critical main loops prevents this per-request work from delaying model execution. The following diagram shows these main-loop and background-thread handoffs for a single request.

Figure 3: Main-loop and background-thread handoffs for a single request in the push-based threading model

Timing comparison of pull and push

The following diagram summarizes the pull and push transfer flows described in the preceding sections and highlights their effect on TTFT. Although both modes use the same NIXL and EFA/RDMA data path, pull performs the metadata relay and decode-side setup after prefill, while push overlaps decode-side setup with prefill. As a result, push removes these operations from the post-prefill critical path, allowing decoding to begin sooner.

Figure 4: Pull and push transfer flows compared, highlighting how push overlaps decode-side setup with prefill

The two modes also involve a routing tradeoff. Pull mode allows the router to select a decode instance after prefill completes, which provides greater flexibility for load-aware routing and quality-of-service management. Push mode selects the decode instance earlier so that destination setup can overlap with prefill. In return, under comparable load, the prefill instance can release its KV blocks sooner because the transfer starts as soon as both the prompt KV and destination registration are ready.

Performance data

For evaluation, we used Qwen3-32B model on a 1P1D deployment using Amazon EC2 P5en instances connected with EFA. To isolate P→D transfer performance, we configured the benchmark to disable prefix caching with --no-enable-prefix-caching. This configuration makes the decode node retrieve the full KV cache from the prefill node for every request. Otherwise, overlapping prompts could reuse the decode node’s local cache and bypass the transfer, which would produce misleading comparison results.

The following chart compares TTFT for push and pull KV transfer. We sweep input lengths 1k–16k and request rates of 1–8 queries per second (QPS). At low load and short prompts, the two modes perform almost identically. As QPS and input length grow, pull mode degrades sharply, reaching about 1,744 ms at 8 QPS and 16k. Push mode stays far lower at roughly 540 ms, around 3x reduction. The gap opens because pull mode posts NIXL descriptors inline on the decode worker, synchronously within its engine loop, so that work stalls token generation. Push mode moves it to a background thread, off the critical path.

Figure 5: TTFT for push compared to pull KV transfer across input lengths and request rates (1P1D topology, 128 output tokens, prefix caching disabled on the decode node)

This chart shows TPOT under the same conditions. The pattern mirrors TTFT. At light load, push and pull are close, around 5.6–5.8 ms. As load and input length rise, pull climbs to about 10.4 ms at 4–8 QPS and 16k, while push holds near 7 ms. The reason is that push offloads descriptor preparation and transfer submission from the decode worker. Token generation is not starved, so per-token latency stays flat even at high concurrency and long contexts.

Figure 6: TPOT for push compared to pull KV transfer across input lengths and request rates (1P1D topology, 128 output tokens, prefix caching disabled on the decode node)

How to run benchmark

To reproduce our 1P1D benchmark configuration, one prefill node and one decode node, using Amazon EC2 P5en instances connected with EFA, refer to the detailed instructions in the Reproducing our results guide. The guide covers environment setup, launching the vLLM prefill and decode servers, running the benchmark, and collecting results. The feature can run on other supported configurations, but performance results will vary depending on the hardware, model, workload, and network configuration.

Conclusion

In this post, we showed how the push-based KV connector overlaps prefill computation with decode-side block allocation and registration, removing the post-prefill router round trip and decode-side transfer setup from the critical path. This reduces TTFT and TPOT, particularly at high request rates. In our Qwen3-32B benchmark on a 1P1D deployment using Amazon EC2 P5en instances connected with EFA, push mode provided up to a 3x improvement in TTFT and 30 percent improvement in TPOT compared with pull mode. Results vary by workload and configuration. To use push mode, configure both the prefill and decode servers to use NixlPushConnector instead of NixlConnector.

Choose the push-based connector when early decode node selection is acceptable and lower TTFT is the priority. The pull-based connector remains the better fit for workloads that require bidirectional KV transfer or defer decode-instance selection until after prefill for load-aware routing. vLLM supports both push- and pull-based KV connectors, so you can select the approach that best fits your deployment.

As a future improvement, we are exploring bringing the background NIXL threading model to the pull-mode connector, moving NIXL setup off the critical path so that pull-mode workloads could benefit from the same optimizations. We have opened a pull request to explore this.

Related resources

• vLLM disaggregated serving guide
• AWS EFA
• Push-mode NIXL KV connector

Acknowledgments

We thank the vLLM community for their support in maintaining this feature.

AI Proved the Quasi-Riemann Hypothesis. What Happens Now?

Among the 377 results that OpenAI announced on October 6, 2026, one stood out. It claimed to settle the “quasi-Riemann hypothesis” — a weaker version of the Riemann hypothesis, which is arguably the biggest open question in math. The new proof is, as Jared Duker Lichtman of Stanford University put it, “the most significant AI-for-math achievement so far, by quite a margin.”

The Riemann hypothesis has been an open problem for over 160 years. Resolving it would enable mathematicians to better understand the nature of prime numbers, one of math’s most crucial building blocks. And that’s just for starters.

The implications of even the more limited “quasi-RH” result are “staggering,” said Maksym Radziwiłł of New York University. “In a sense, the vast majority of consequences of RH already follow from quasi-RH.”

Moreover, contrary to what mathematicians had long expected, the proof didn’t need to introduce any new concepts — it instead unearthed hidden connections between old ones. “The proof is a surprising synthesis of well-known ideas,” said Alexander Dunn of the Georgia Institute of Technology.

The result relied in part on techniques pioneered by Radziwiłł and Dunn. Alongside other number theorists, they have been working to understand the proof and what it could mean. Now they’re starting to get answers.

To Zeta and Beyond

To understand what the quasi-Riemann hypothesis says, you first have to understand the Riemann hypothesis. When the Clay Mathematics Institute announced seven Millennium Prize Problems at the turn of the century, the Riemann hypothesis loomed above the other six. It was the only one carried over from the celebrated agenda-setting list of problems that David Hilbert had announced a century earlier.

On its surface, the conjecture concerns the behavior of a particular function. Start with the sum 1 + 1/2 + 1/3 + 1/4 + ⋯. Now use that sum (together with a special mathematical trick to extend its scope) to build a more general function, called the Riemann zeta (ζ) function:

ζ(s) = 1 + 1/2^s + 1/3^s + 1/4^s + ⋯

Here, the input s is a complex number. Complex numbers have two parts — a “real” part and an “imaginary” part, which is a multiple of the square root of −1 (written as i). Any complex number can be thought of as a point on a plane.

The Riemann hypothesis is about which values of s will make the zeta function equal zero.

But it is also about far more than how this particular function behaves. As Bernhard Riemann realized when he first made the conjecture in 1859, the function relates to patterns in the prime numbers — integers divisible only by 1 and themselves that many mathematicians call the “atoms of arithmetic.”

It’s long been known that as you move along the number line, the primes thin out. Riemann showed that exactly how the primes thin out is, in a sense, governed by the zeta function — in particular by the places where it equals zero.

It’s straightforward to prove that if s is a negative even number (−2, −4, −6, …), then ζ(s) = 0. These are called trivial zeros. The Riemann hypothesis says that the only other zeros of the zeta function, called nontrivial zeros, occur when s has a real part of 1/2. That is, they should all be located on a vertical line.

If any nontrivial zero were to be found somewhere away from that vertical line, it would imply that the primes must form an extremely surprising pattern, one that has never been observed to date.

Just narrowing the area where the nontrivial zeros can appear has had huge ramifications. Riemann himself proved that nontrivial zeros of the zeta function can only be found in a vertical strip between zero and 1. Then, in 1896, two mathematicians showed that zeros could not lie on the edges of the strip. As a direct consequence, they were able to prove an important result called the prime number theorem, a formula for how quickly, on average, the primes thin out.

If the Riemann hypothesis holds, then mathematicians can guarantee that any deviations from the average given by the prime number theorem will always be small.

Mathematicians have numerically verified that the first 12 trillion nontrivial zeros are on the 1/2 line. But they can’t be sure the hypothesis holds for all the zeros, and even one solitary outlier would land like an earthquake. As Enrico Bombieri wrote in the paper laying out the Millennium Prize formulation of the problem: “The failure of the Riemann hypothesis would create havoc in the distribution of prime numbers.”

Diamonds in the Slop

This brings us to the quasi-Riemann hypothesis. Where the Riemann hypothesis posits that all the nontrivial zeros are on the vertical line at 1/2, the “quasi” version just asks one to prove that they are all contained in a vertical strip that’s narrower than the known strip between zero and 1. The narrower the strip, the more one can say about how the primes are distributed.

OpenAI announced two different versions of their quasi-Riemann hypothesis proof. The first version, dated September 30, 2026, claimed to show that all nontrivial zeros must be between 1/8 and 7/8, and was formally verified using the Lean programming language. The second version, which was completed almost a week later (and is not yet formally verified), claimed to prove a weaker result: that the zeros must have a real part between 1/12 and 11/12. But while the first paper is 199 pages long, the second weighs in at a comparatively modest 49 pages.

As with many recent AI-generated results, both papers “are horribly written (in a way that would lead to immediate rejection at any mathematical journal),” Radziwiłł said in an email. “They fall short of the standard of exposition and clarity in our area by a wide margin.” And so mathematicians have set aside the 7/8 paper to focus on the 11/12 one, which seems to involve similar techniques and has similar consequences. “The reason why people look mostly at the 11/12 result is that it’s shorter,” Radziwiłł said.

Not coincidentally, the 11/12 result is the only one of the 722 OpenAI papers released on October 6 to have been edited by a person. OpenAI has not addressed inquiries about who that person is, or why this is the only paper to have had the benefit of human expertise before being released. In response to questions from Quanta, the company said, “The paper is the result of work from everyone at OpenAI.”

Mathematicians have been studying the paper intensely in the couple of weeks since its release. Peter Sarnak, a prominent number theorist at Princeton University, has decided to repurpose a course he’s teaching this semester to study it. Radziwiłł says he can now sketch the proof’s arguments in half a page, while more involved write-ups by other mathematicians range from seven to 13 pages. (As of this writing, these have not yet been published, but are circulating privately.) These experts largely agree that the result is correct — and that its novelty lies in the way it brings together ideas from number theory that have been around for some time.

For decades, Sarnak has argued that mathematicians should approach the Riemann hypothesis by considering the zeta function as just one member of a broader family of functions, and then proving statements about that family. “But it was not clear exactly how to do so, or which family to consider,” said Michael Rubinstein of the University of Waterloo.

As it turns out, Sarnak had the right intuition. But the family that OpenAI’s model identified had previously been overlooked. The Rutgers University mathematician Henryk Iwaniec narrowly missed it in 2002, when he identified a number of closely related families in an effort to prove the Riemann hypothesis.

Finding the right family required obscure mathematical objects called metaplectic forms, which Dunn has spent the past five years studying. “Nobody expected this,” he said. Metaplectic forms had been somewhat uncommon in number theory until now, he added, “so I hope this beautiful and esoteric theory gets the attention it deserves.”

To Dunn and Radziwiłł’s surprise, a formula they had proved in 2021 became a crucial ingredient in the proof (along with the work of numerous other mathematicians). In retrospect, Radziwiłł said, mathematicians who study the branch of number theory that all this work belongs to were mistaken in thinking that their tools weren’t strong enough to resolve the quasi-Riemann hypothesis. They’d been convinced that proving it would require techniques from another branch of number theory entirely. The AI model’s “belief” that their tools might be enough was a crucial perspective. “That was a pretty bold belief to have!” Radziwiłł said.

Mathematicians are both frustrated and excited by OpenAI’s work. Sarnak, for his part, said in an email that he won’t be satisfied that it’s “a Theorem” until humans check and understand all the details. But “the general feeling is one of relief,” Radziwiłł said. There are scores of results across not just number theory but also geometry and theoretical computer science that the proofs of quasi-Riemann will, in a swift stroke, establish as mathematical truths.

Number theorists are skeptical that the result’s particular combination of techniques will let them take the 7/8 bound down to the tantalizing 1/2. “It seems most likely to me that once mathematicians have fully internalized the new methods and worked through their implications, we will still feel as far off from the full Riemann hypothesis as we were before,” said Will Sawin of Princeton. “But I am not certain of this.”

Thomas Bloom, a mathematician at the University of Manchester, agreed that the full Riemann hypothesis still seems out of reach. But, he added, “we would have said the same about quasi-RH a few weeks ago! At this point nothing would surprise me.”

Prologue

Like last year, I livetooted the release of Python 3.15.0. Here it is in blogpost form!

Two weeks

Two weeks until Python 3.15.0 final!

One week

One week until Python 3.15.0 final!!

What are you most looking forward to?

Python 3.15.0 release day!

First blocker, we’re getting 503s on docs.python.org and buildbot.python.org, the latter of which is needed to check the tier 1 and 2 buildbots are passing, needed for a release.

It’s a certificate issue from an incompatible pyOpenSSL upgrade. We’re waiting for the US to wake up and poke it with a stick.

Red

The US woke up and they’re both back up!

Now, there’s one tier 1 failure to check.

Flaky

RuntimeError: join took too long: <Process name='Process-2107' pid=2290504 parent=2276730 started daemon>

Looks like a flaky test, and python/cpython#157184 has a fix to increase a timeout. Will try restarting for now.

Green

That passed, the buildbots are back to green ✅️

Next, issues/PRs with release-blocker label.

One is a straightforward docs update, I marked as blocker so I don’t forget, to change future tense to present.

Then three last-minute lazy import blockers that need a closer look.

Traditional surprise rc3

Following recent tradition, I’m going to add a surprise third release candidate!

It makes sense to include the last-minute lazy-import fixes in 3.15.0 final.

It also makes sense to give time to test them properly, so today’s planned 3.15.0 final is postponed, and I’m going to release a 3.15.0rc3 tomorrow, assuming everything is in place.

And then 3.15.0 final will follow about week later. Exact date to be announced.

We’re nearly there! 🤞

Missing backport

The three lazy blockers are finally merged into main, two have been backported to 3.15, but wait, the third failed, because it depends on some tests not yet backported.

Okay, backport created, merge conflict fixed, CI is now spinning, and automerge enabled. That’ll merge in about 15 mins, then we can update it into the last blocker PR, that should merge about 30 mins later, and rc3 can begin!

rc3

Get yer rc3 here!

You know the drill: please test and report bugs!

Library maintainers, join the Cool Testers’ Club 😎 and add 3.15 to your test matrix.

Python 3.15.0 final planned for 2026-10-09.

Python 3.15.0 release day (second attempt)!

✅️ Release date updated in What’s New in Python 3.15

✅️ No release blockers

✅️ No deferred blockers

✅️ Buildbots all green

Cooldowns

Pydantic finally added support for Python 3.15 yesterday, and aiohttp on Monday, so I could use Python 3.15 rc3 to run the release scripts and release Python 3.15.0 final!

But… I’m going to respect our seven-day cooldown, and stick with 3.14.

You also use cooldowns for your dependencies, right?

blurb bug

Pushing the big launch button:

.venv/bin/python run_release.py --repository ../cpython --ssh-user hugovk --release 3.15.0

… and immediately ran into a bug with our changelog tool blurb, because we’ve had no new NEWS fragments since rc3 :)

This needs a fix in blurb, a new PyPI release, and then the docs lockfile regenerated and backported to 3.15.

Fix PR: python/blurb#92

blurb fix

OK, merged and released (really easy using Trusted Publishing), lockfile updated and backported.

Restarted the release and that’s better now.

A temporary branch and tag has been pushed to my fork, and I need to verify the release commit does not contain any unexpected changes.

All looks good. Next to start the installer and artifact builds.

Installers

The release artifact build failed, need to bump blurb in that lockfile too.

Like this: python/release-tools#451

Now restarted that workflow with the existing CPython tag, no need for retag.

This builds source+docs tarballs and Android+iOS artifacts. Takes ~30 mins.

Ned Deily has started the macOS installer builds. And I’ve started the Windows installer builds, takes ~2 hours.

SBOM

In the meantime, the GitHub Actions build has finished, SBOMs created and some things uploaded.

The Windows process has paused a couple of times, awaiting button clicks to approve signing of binaries. The whole release team gets emails about this, so no sneaking out signed releases. 🥷

Nearly there

Windows complete, tags pushed upstream, Sigstore signing done, adding files to python.org… nearly there…

Out now

🐍🚀 Out now: Python 3.15.0 final!

💤 Lazy imports!
🧊 frozendict builtin!
💂 sentinel builtin!
📉 Tachyon profiler!
🖼️ Frame pointers everywhere!
🛅 Unpacking in comprehensions!
🗣️ UTF-8 as the default encoding!
🛞 Stable ABI for free-threading!
🆕 Package startup config files!
⌨️ TypedDict & TypeForm!
🐎 Faster JIT!
🎨 More colour!
🚌 & more!

Huge thanks to the Sovereign Tech Agency supporting my work as release manager and enabling another smooth release!

It’s not over yet!

I updated PEP 790, which also updates the PEPs API, which is used to point the docs at /3/ to 3.15, kicked off a docs build: docs.python.org/3/

Unpin one toot and pin another to my profile.

(3.14 might not be the newest, but we can still celebrate with pie!)

And then unlock the 3.15 branch so the core team can start merging 185 PRs that didn’t get in during RC.

Also

✅️ update 3.15 label
✅️ rebuild devguide to update: devguide.python.org/versions/
✅️ unlock 3.15 branch

And I think that’s it!

Hey, @savannah, you’re up next with the first 3.16 alpha on Tuesday! 🚀

US bans China's DeepSeek from government in race for AI dominance

The US has ordered all artificial intelligence (AI) technology from the Chinese firm DeepSeek to be removed from most government systems.

The Department of Homeland Security (DHS) has banned all use of DeepSeek within civilian government agencies, and any technology built with the aid of its AI models.

As a powerful AI model that is open source - meaning it is free to access and less expensive to use - DeepSeek has been seen as a disruptive force in the ongoing AI technology race.

While the DHS notice did not detail the exact security concerns surrounding DeepSeek, the White House has this year criticised AI firms from China.

The DHS, DeepSeek, and the Chinese embassy in Washington DC have been contacted for comment.

The DHS made the order public on Monday, but the ban took effect from the end of July.

The order is specific to civilian agencies, including the Department of the Treasury, the Department of State and the Department of Justice. However, agencies within the Department of Defense are excluded.

The ban follows criticism of Chinese AI from the Trump administration, and from American firms.

White House tech lead Michael Kratsios wrote earlier this year in an internal memo that "malicious exploitation" of American AI firms had been occurring, mainly by rival firms in China.

Anthropic and OpenAI, both of which are poised to list on the public stock market in the coming months, have also claimed to have had their AI models essentially copied by some Chinese AI firms, including DeepSeek.

US president Donald Trump has made clear that he sees China as the key US rival when it comes to development of AI, something he sees as crucial to the future of the country.

DeepSeek has grown in popularity since its initial public release in 2025, with models being in such demand that the company's servers have gone down at times.

While DeepSeek's free chatbot app is one of the most downloaded apps in the Apple App Store rankings, its AI models are also used by US tech companies. Companies like Snowflake, Vercel and OpenRouter all incorporate DeepSeek in their offerings to customers.

Startups have flocked to open source models like DeepSeek.

For a technology or AI developer, using DeepSeek in their work costs a fraction of what a closed model like Google's Gemini, Anthropic's Claude or OpenAI's Codex would.

Similarly, the expense borne by DeepSeek to develop its models has been astronomically less than what it has cost US AI firms to develop their own.

Last year, DeepSeek said it took about $6m (£4.5m) to train the debut version of its model, while the costs associated with OpenAI's GPT-4 were roughly $100m. Such revelations sent tech stocks tumbling.

The most recent version of DeepSeek was released last week. Users of the model have praised it online, saying it beats even the most advanced AI tools out of OpenAI on common tasks for AI tools like computer software coding.

WCAG 3, still a draft, is the first ground-up rebuild of the standard since 1999, proposing to replace binary pass/fail with a graded model where meeting core requirements is a floor. Bronze, silver, and gold levels would let organizations be recognized for going further. Accessibility laws point to WCAG, so the change must keep regulators able to adopt it.

Diffusion at Scale: Introducing Mercury 3

Today we’re introducing Mercury 3, the most capable diffusion-based LLM released to date. Across a range of benchmarks, Mercury 3 outperforms GPT-6 Luna and Claude Haiku 5.5, while running 4–8x faster at 1,000+ tokens per second.

Mercury 3 demonstrates that text diffusion scales. It’s more than 40x larger than Mercury 1 and is vastly more intelligent, but just as fast.

Early-access partners already use Mercury 3 for voice and chat support, real-time tutoring, data engineering, and web navigation:

Mercury 3 at a glance

• Quality: On par or better than frontier speed-optimized models like GPT-6 Luna and Claude Haiku 5.5.
• Speed: 1,068 tokens per second on NVIDIA GPUs.
• Context: 1M tokens, up from 260K for Mercury 2.5
• Price: $0.20 per million input and $0.70 per million output tokens.
  • At launch, Mercury 3 is 50% off at $0.10 per 1M input and $0.35 per 1M output. Cached tokens are 90% off the input price.

Diffusion at scale

When we launched Mercury 1, it was the first proof point that diffusion LLMs could be built for commercial applications. The open question in the AI community was whether diffusion LLMs could scale to compete with autoregressive models on complex use cases.

Mercury 3 answers that question: they can. We’ve scaled Mercury more than 40x in total parameters, and intelligence across a range of standard benchmarks has risen 3x from Mercury 1 (mini) to Mercury 3. The scaling laws that drove progress in autoregressive models hold for diffusion too.

Mercury 3 in production

Early-access partners are already running Mercury 3 to power latency-sensitive applications such as browser use agents, interactive education, real-time search agents, and customer support.

Browser Use Agents

Agents wait on the model at every step, so small delays compound quickly. Mercury keeps each pass fast, whether the agent is navigating websites, researching across sources, or analyzing logs and tracing incidents. Agents finish sooner and have time to try more approaches before answering.

We ran Mercury 3 inside our production web-agent harness against frontier models, on 50 live Mind2Web navigation tasks. Mercury 3 completed 50% of them, significantly more than GPT-6.1-Sol. It did so using the same token volume and the same number of agent steps as a frontier model, at a fraction of the per-token cost.

Interactive Education

Learning runs on fast feedback loops, and any delay pulls a student out of the material. Mercury reasons through each request and responds in near real time, whether it’s a voice tutor carrying a conversation, an assistant grading work, or an app adapting the next question to what the student just got wrong.

Mercury 3 allowed us to give every student instant feedback without giving up reasoning. Hints, marked answers and definitions now come back in about a second, with quality as good as or better than the models we ran before. When a student is stuck on a question, that speed keeps them working instead of waiting, and it was a drop-in swap for our existing stack.

Real-time search agents

Search applications start to feel unresponsive after just a few seconds delay. Mercury 3 runs fast enough to process dozens of documents and still answer while the user is engaged.

On smart glasses, an answer that takes five seconds feels broken. In our Sense API tests, Octen search took about 80ms; model generation was the bottleneck. Mercury 3 delivered the best balance of speed and quality among the fast models we tested, with a median generation time of 0.9 seconds and a median end-to-end response time of 2.2 seconds.

Customer support

Support agents have to answer quickly, often for regulated businesses where a wrong answer is costly. Mercury keeps responses conversational without sacrificing accuracy.

At Lorikeet, we help complex and regulated businesses build a concierge for their customers that works across voice, chat and email. In chat and voice, customers need fast responses, but we can't compromise on accuracy or getting the job done correctly. In early testing, Mercury 3 beat other models on latency while also performing higher on evals and in production.

A real-time product portfolio

Mercury 3 is the flagship model in a widening portfolio of products that enable real-time AI.

• Mercury Voice: Mercury Voice is customized for the extreme low-latency requirements of voice applications and for minimizing time to first answer token (TTFAT), not just end-to-end latency. It’s already powering agents at Audivi AI, Altur, and OpenCall.
• Mercury Decide: Mercury Decide is a decision model built for high-volume classification. It outperforms Jev on benchmarks including JevBench and LegalBench.

Get started

Mercury 3 is available today on the Inception API Platform and through OpenRouter, Baseten, and Vercel. It is OpenAI API compatible, so it drops into your existing stack with no rewrites. Enterprise deployments support dedicated capacity, autoscaling, compliance controls, and configurable data retention.

• Try Mercury 3 in chat
• Try the API with 100 million free tokens
• Read the API docs
• Enterprise evaluations: we'll partner with you on workload fit, eval design, and performance under your serving constraints. Contact us.

Mercury 3 is live. Diffusion scales.

Full article content is not available for inline reading.

Read the original article →

Full article content is not available for inline reading.

Read the original article →

• Sometimes, giving an AI agent all of the knowledge it needs is the wrong approach.
• At Meta, we’ve seen notable improvements in efficiency and accuracy by keeping the orchestration layer of our data pipeline agents deliberately thin: It routes work and enforces reliability checks, while specialized agents do the domain reasoning.
• We’re sharing our own process and insights, plus how any team can apply this to their production AI agents.

We built a 1,300-line orchestrator that routes 20+ workflows to 14 specialized AI agents. It performs zero domain work itself. That’s the point.

When we first deployed AI agents to automate data column onboarding across Meta’s recommendation systems — a process spanning three code repositories, three programming languages, and up to six pipeline stages that must stay in sync — we did what most teams do: We built one smart agent that knew everything.

It worked in demos. In production, it started hallucinating.

The fix wasn’t better prompts or a bigger context window. It was giving the central agent less to do. We call this the thin orchestrator pattern: a router that owns sequencing and reliability checks, and leaves every domain decision to specialists.

The Problem: More Context, Worse Results

Our pipeline is config-as-code: Python configurations drive C++ code generation, which feeds data processing services, which populate analytics systems. Onboarding a single data column requires coordinated changes across configuration registries, backend services, and data pipelines, and each column moves through up to six stages before its data arrives.

Our first approach was a single AI agent loaded with all domain knowledge, configuration schemas, code generation rules, pipeline routing logic, validation requirements, and population patterns for 10+ data sources.

The agent had everything it needed. That was the problem.

Past a certain context threshold, additional knowledge degraded rather than improved performance. The agent would cross-contaminate concepts, applying field naming conventions from one subsystem to another, or using a code generation pattern meant for one data source when populating from a different one. A preprint from the Windreich Department of Artificial Intelligence and Human Health at Mount Sinai found that orchestrated multiagent systems held 65.3% accuracy at 80-task batches where single agents fell to 16.6%, while reducing token usage up to 65-fold. The authors attribute this to the design’s isolation of tasks, which prevented context interference. We were experiencing the inverse, a single agent drowning in its own knowledge.

We also evaluated an alternative single-agent approach. Its success rate was 70-80% with manual prompt engineering per task: An engineer had to craft a custom system prompt for each specific job. Without that handholding, success dropped to 10-20%. This wasn’t a prompt engineering problem. It was an architectural one.

The Approach: A Thin Router With Specialist Workers

We split the system into two layers:

1. A deterministic orchestrator that performs zero domain work. It classifies intent, gathers required fields, runs reliability checks, and delegates to the right specialist. It never reasons about code, never generates configurations, and never touches the codebase. It’s a router.
2. Fourteen specialized subagents, each a complete domain expert with isolated context. A schema management agent knows configuration registries. A population agent knows how to generate code for each of 10 data sources. A validation agent knows build systems and quality checks. No agent sees the full picture. That’s the feature, not the bug.

The orchestrator follows a fixed 7-step protocol for every request:

1. Read the relevant subagent’s instruction file.
2. Check if the target already exists (prevent duplicates).
3. Gather required fields from the user.
4. Auto-discover what can be inferred (repository type, existing configurations).
5. Reliability gate check for active warnings or required reviewers.
6. Delegate to the subagent with full context.
7. Handle results and surface errors, confirm success.

Steps 1–5 and 7 are deterministic. Only step 6 involves large language model (LLM) reasoning, and it happens inside an isolated subagent with only its domain knowledge loaded.

What We Built: Workflow Templates, Not New Agents

One architectural insight was separating what needs to happen from how each step is performed. The orchestrator defines phase ordering through workflow templates — deterministic state machines that constrain the LLM’s decision space:

• Column Onboarding: Schema → Validation → Population → Testing
• Event Onboarding: Schema → Population → Validation → Testing → Event Processing
• Pipeline Migration: Assessment → Planning → Population → Validation → Monitoring

Each workflow template reuses the same pool of 14 subagents in different sequences. When we needed to support pipeline migration, a completely new use case, we didn’t build new agents. We wrote a new workflow template that sequenced existing agents differently. Zero new agent code. Full production capability.

Each subagent follows a standardized structure:

• Knowledge sources: which domain files to load at runtime (typically a few thousand tokens each).
• Pre-gathering checklist: what the orchestrator must collect before delegation.
• Step-by-step workflow: the domain-specific execution plan.
• Discovery patterns: how to find relevant code patterns in the monorepo.
• Troubleshooting: error-to-resolution mappings for common failures.

This uniformity means adding a new subagent is templated work, not greenfield engineering. The 15th subagent looks structurally identical to the first.

Knowledge files are loaded on demand at subagent execution time, not embedded in the orchestrator. We maintain 25+ knowledge files organized by workflow domain. When a knowledge file is updated, the next session automatically uses the latest version — no orchestrator changes required. The same knowledge files serve multiple platform implementations of our agent.

Results

Configuration prep for a new column took three to four days by hand and about a day with our earlier config-driven system. The thin orchestrator system does it in under an hour.

For broader context: About two-thirds of the system’s changes land without significant human edits. It gets there by trading generality for deep domain knowledge, a deliberate architectural choice. The orchestrator is general; the subagents are specialists.

Why This Works (And Why Heavyweight Orchestrators Don’t)

The conventional approach is to make the orchestrator the smartest component — give it all the context and let it reason about what to do and how to do it. This works until it doesn’t, and it stops working exactly when you need it most — at scale, with complex multi-step workflows, across heterogeneous subsystems.

The thin orchestrator works because it aligns architectural boundaries with computational boundaries:

• Deterministic decisions stay deterministic. “Which subagent handles this?” is a routing decision, not a reasoning task. Don’t use an LLM for it.
• Context isolation prevents cross-contamination. The population agent for data source A never sees data source B’s patterns. It can’t hallucinate the wrong one.
• Failures are contained. If a subagent fails, the orchestrator retries or escalates. The failure doesn’t corrupt the orchestrator’s state or other subagents’ contexts.
• The system improves at every layer independently. A better model improves all 14 subagents simultaneously. A knowledge file update takes effect immediately. A new workflow template unlocks new capabilities without touching agents. No single component carries the full weight.

How to Apply This to Your AI Agents

1. Separate routing from reasoning. If your orchestrator is making domain decisions, it’s doing too much. Routing should be deterministic: keyword matching, intent classification, field gathering. Push all domain reasoning into isolated subagents.
2. Design subagents as structurally uniform specialists. Every subagent should have the same structure: knowledge sources, required inputs, execution steps, error handling. This makes adding new capabilities templated work rather than architecture changes.
3. Use workflow templates, not new agents, to scale. When you need a new use case, first ask: Can I sequence existing agents differently? If you can’t reuse agents across workflows, your agents are too coupled to specific use cases.
4. Load knowledge at runtime, not at build time. Embed knowledge in the orchestrator and every update requires redeployment. Load it on demand and updates take effect immediately, across all platforms.
5. Draw the deterministic/probabilistic boundary explicitly. For every component, decide: Is this a routing decision (deterministic) or a reasoning task (probabilistic)? The orchestrator should be on one side, the subagents on the other. Don’t mix them.

The strongest argument for a thin orchestrator is the failure mode of the alternative. When a heavyweight orchestrator hallucinates, the error spreads to everything downstream: it routes to the wrong agent, gathers the wrong fields, or skips reliability checks. A thin orchestrator leaves little room for hallucination because its routing and reliability steps don’t rely on LLM reasoning. It follows a fixed protocol. The creativity happens downstream, in isolated, domain-scoped contexts where hallucination risk is minimized and failures are contained.

What’s Next

We’re scaling this architecture to handle an increase in data columns across new pipeline domains. The compositional thesis predicts this will work because scaling means adding workflow templates and knowledge files, not rebuilding agents. We’re also exploring how the system can continuously improve from production usage, using automated feedback loops to identify failure patterns and propose targeted improvements to subagent knowledge, with human review always gating any changes.

The counterintuitive lesson: the most important component in our AI agent system is the one that does the least work. Keep your orchestrator thin and your specialists deep, and the whole system becomes more reliable.

Acknowledgements

This work was a team effort. Some other people who contributed to this effort include: Mani Bhushan, Rahul Maliakkal, Jae Ha, Chakrapani Kumar, Vivek Tiwari, and Amanda Yin.

Apple will be holding a product launch event on October 28 to debut its first touch-screen MacBook. The company will also introduce a new low-end MacBook Pro with an M6 chip, a refreshed iMac, and a revamped iPad mini with a sharper screen. Apple retail stores are preparing to begin selling new products on November 6. The new touch MacBooks, which will run on M5 Pro and M5 Max chips, will have a Dynamic Island interface, as well as a sharper OLED display.

Full article content is not available for inline reading.

Read the original article →

When we previously blogged about our AI code reviewer in April, an average review cost a palatable $1.19. By the end of August, that figure had shot up to about $2.46. We hadn't made any significant architectural changes: the coordinator was still handing work to the same set of specialist reviewers, and the same risk tiers decided how intensive of a review we gave.

Around mid-September we tasked our agents with working out where those tokens were going and cutting them — aggressively. With code quality at high effort, the average review now costs just $0.77, down 68% from the $2.43 it averaged over our two most expensive weeks before we started. Our main goal was to cut costs, but as part of this work we also managed to optimize the reviewer, so that the median review now takes just 1m 32s instead of the 4m 09s it took before.

About 40% of the savings came from changes and optimizations to the reviewer's code, and the rest from experimenting with which models we use and how much effort they put in.

How a review doubled in cost

The chart below shows the cost of an average review on each weekday since March. It holds the mix of review tiers fixed, so a day with more large reviews doesn't skew the data.

The cost per review steadily rose from $1.22 (March) → $1.44 (June) → $1.74 (July) and finally, to $2.32 (August). A small part of that is that more reviews landed in the most expensive tier (59% of reviews in March and then 65% in August). We believe there’s a simple answer for why: models are getting much better, and much more capable. Naturally, engineers are producing bigger, more complex changes which means more of them fall into our “full review” tier. We found that most of the cost increase actually came from model changes over those months, though.

At the start of August we moved every reviewer onto Anthropic models, which raised the cost per job from $1.38 to $2.03. We made this choice because we found that during our evals, Anthropic models performed better on this specific workload than other models.

Our internal standards reviewer, Codex, ended up on Claude Opus 4.7 due to a mix of performance and reliability. That took it from about $0.25 per review to $0.88 in August, which made it more expensive than the coordinator agent itself.

The cache hit rate also increased, going from 85.7% in April to 97% by September, while the number of tokens per review more than tripled, from 0.91 million to 2.99 million. A high hit rate on three times as many tokens still costs a lot more, even with the low cache read cost.

What else has changed since our last post?

One of the biggest changes is that the reviewer now runs on OpenCode v2, which is a ground-up rewrite from v1. Before switching all reviews over from v1 to v2, we ran every review in every canary repo on both v1 and v2 in a comparative shadow mode. The two agreed on the approval decision in 98% of the merge requests we tested, so we moved everyone over in one go in early October and removed the v1 code. Comparing two days with the same models, full-tier reviews on v2 finish about 13% faster. We’re also currently experimenting with other ways to run our internal AI reviewer, including solely on Durable Objects using pi-durable. We’re hopefully going to have more on this coming soon, so keep an eye out!

So, where were the tokens going?

Right before we started focusing on cost optimization, our AI review spend was split by: output tokens making up about 23%, cache writes cost 43%, and cache reads cost 34%. This means that most of the money was going on context the model had already seen or was about to see again.

That makes complete sense when you look into a single session. The code quality reviewer made 16.6 large language model (LLM) calls per review on average and over those calls it wrote 72k tokens to the cache and read back 1.08m, because each call sends the whole conversation as context. A session's cost grows with both the number of calls and the size of the context, and over the last few months we had slowly increased both.

It’s worth taking a few minutes to read about how Anthropic's prompt cache works. It works by caching parts of the prompt that have already been computed by the large language model (LLM). These are known as prefixes, because they only work on the messages at the start of the conversation, not mid way through or the end. This means that a future request can reuse an earlier prefix, up to the part of the conversation that changes from what’s been cached. In our case, the harness tools, system prompt and messages at the start of our AI reviewer sessions rarely change, so they’re a great candidate for prefix caching. A prefix is only stored where a cache breakpoint ends it. Writing to the cache costs 1.25 times the normal input price and reading costs 0.1 times, and an entry expires after five minutes unless something reads it.

That means we had two things to work on: make the first request of each session read from the cache instead of writing to it, and make each session use fewer calls.

Sharing a cached prefix between every repository

Beginning September 14, the reviewer recorded the token usage of each reviewer's first LLM call, plus a hash of the first system block exactly as it was sent to the provider.

The data showed that the first request of a session found a cached prefix only 14% to 26% of the time. Every session starts with the same tool definitions and the same agent prompt, between 11k and 21k tokens that are identical in every repository we review, so almost all of them should have been cache hits.

The problem ended up being in how OpenCode v1 constructed the system prompt: It built one block containing our agent prompt, followed by an environment section with the working directory and the date, and placed the only cache breakpoint at the end of that block. The shared part was never stored on its own, so a review in one repository could never reuse what a reviewer ran in another repository had written.

On September 16, we added a marker to the end of every agent prompt and a plugin hook that split the block in two at that marker. The first half now ended on bytes that every job shares, and got its own breakpoint. To keep it that way we had to remove anything repository-specific from in front of it, so the list of available skills is disabled and tool descriptions can't change between jobs.

The same day we also moved our internal standards (Codex) reviewer's reference index (a table of internal standards, a skill file and a list of reference files) into its prompt. Until then every session had spent its first three turns reading those files with tool calls. Its LLM calls per run decreased from 15.9 to 9.6, and its cost per run dropped from $1.12 to $0.72.

Together these took the cost per review from $2.47 down to $2.02, and the drop was noticeable as soon as we kicked off the release.

Fewer calls, fewer dollars

The next set of changes went out on September 21 and 23. None of them were particularly impressive by themselves, but together they took about $0.20 off every review.

The most involved change was sharing one prefix between three reviewers. The code quality, security, and performance reviewers now send identical first requests with the same tools, a shared rules file, then the merge request with every patch included. Each reviewer's own instructions follow after that, and we make sure that one of them writes the cache and the other two read from it.

A cache entry can't be read until the response that wrote it has started streaming, and the three reviewers start at the same time. So the second and third wait for the first one's response to begin, for up to 20 seconds, before sending their own first request. It slows them down slightly and saves about nine cents per reviewer.

Changing models and effort

When we split the period at every release and every configuration change, the code changes turn out to be the smaller part of the saving.

Code changes account for $0.65 of the $1.67, and model and effort changes for $1.06. Each step compares the weekday hours before a change with the hours after it, so this isn't a statistically sound controlled experiment.

The coordinator had been running three model and effort combinations since August. On the same model, full-tier jobs on medium effort finished 20% sooner, so we dropped the other two. In a later randomized split, Opus 5.5 at medium showed no measurable change in review outcomes or critical findings compared with Opus 5, so we switched. Opus 5.5 at high effort cost more than Opus 5.5 at medium while not producing a meaningful increase in findings.

Opus 5.5 is cheaper per token than Opus 5, but price is only responsible for about $0.20 of the drop. The rest comes from sending and generating fewer tokens. Since the start of September cache reads per review are down 82%, cache writes down 54%, and output down 67%.

The most recent change was a new model. On October 3, we split every Sonnet reviewer 50/50 between Sonnet 5 and Sonnet 5.5. After two and a half days, Sonnet 5.5 was 62% cheaper per run for code quality, 58% for performance and 47% for security. The two models cost the same per token, so all of that comes from using fewer tokens. On full-tier reviews, the 5.5 reviewers posted about as many critical and warning findings as the Sonnet 5 ones, so on October 5 we moved all of them to 5.5.

On Sonnet 5.5 at medium effort, the code quality reviewer makes 1.7 LLM calls per run instead of 6.2, and more than half of its runs finish in a single call, which means they don't open any other file in the repository. At high effort it makes 3.4 calls per run. We were concerned that this made reviews shallower, which we cover in the quality section below.

To see whether more effort brings findings back on the larger tiers, the code quality reviewer has been split 50/50 between medium and high effort on 5.5 since October 5. After one day, high effort costs 61% more per run and posts 58% more critical and warning findings. That's about two cents per review, and the quality section below shows those extra findings are worth having, so we're moving code quality to high effort. The cost figures in this post assume that.

Latency

We weren't aiming to make reviews faster, but fewer calls also means less waiting, which means faster reviews and happier engineers.

The slowest reviews improved the most. In the four weeks before September 14, 37.9% of reviews took longer than five minutes and now just 0.7% do. The 99th percentile today is faster than three quarters of reviews were in April. Every tier got faster along the way with the median full-tier review going from 5m 16s to 1m 54s, lite from 2m 58s to 1m 14s, and trivial from 77 seconds to 30.

By August, the median review was 14% slower than what we reported in April and the 99th percentile 48% slower, so a good part of this work just got us back to where we had been.

Review quality

A cheaper review isn't worth much if it also finds fewer problems, and the first chart here looks like that's what happened.

With code quality on Sonnet 5.5 at high effort, it posts 40% fewer critical and warning findings than it did in late August. Security and performance, which stay at medium effort, post 56% and 71% fewer. A fall in severe findings doesn't tell you on its own whether real problems are being missed or noise is being cut, so we looked at it from two directions.

First, we checked whether authors act on what the reviewer flags. For samples of critical and warning findings, we compared the commit that was reviewed with the author's next push, and counted a finding as acted on if the lines it pointed at had changed. Lines 30 to 40 away from each finding changed about 15% of the time in every period, which gives a baseline for edits that happen by coincidence.

Before the changes, authors acted on 34% of the code quality reviewer's serious findings. Now it's 59%. The reviewer flags fewer things, but those it flags are much more likely to lead to a change, so the number of findings that led to a change per 1,000 reviews is about the same. We now saw 132 against 145 before, which is within the margin of error. Across all four reviewers, serious findings that led to a change went from 229 to 321 per 1,000 reviews.

Second, we had two models from different providers judge a blinded sample of 657 findings from the three Sonnet reviewers, with the diff each one referred to and without knowing which period it came from. Disagreements went to a third model. Each finding was labelled important, minor, duplicate, wrong, or unverifiable, and its severity was marked as fair, too high, or too low.

Most of what disappeared was minor findings, plus some duplicates and findings the judges couldn't verify from the diff. Important findings per review went from 0.28 before to 0.30 now, and the intervals overlap. The bigger change was in severity. Before, the judges rated 0.46 critical or warning findings per review as more severe than they deserved. Now that's 0.14, a 70% drop and the clearest result in the research. Much of the drop in critical findings is the reviewer no longer calling minor things critical.

So the answer depends on the reviewer. For code quality at high effort, what disappeared was mostly noise and inflated severity, and it still finds about as many real problems as before. Medium effort did lose real findings. In the randomized split, code quality at medium led to roughly a quarter as many acted-on findings as at high, which is why we're moving it to high. Performance also lost real findings: the judges found about 64% fewer important performance issues per review, which in practice is about one fewer important finding every 24 full-tier reviews. Security fell by about a quarter, though that isn't statistically significant. Both are still at medium effort, and testing them at high is next.

Neither method is perfect. An author changing the flagged lines shows they did something, not that the finding was right. The judges are models too, and there are only 35 to 66 findings in each group. The "now" window is also only a day long. Even so, the two methods agree with each other, and neither suggests that code quality is finding fewer real problems.

Reliability has held up as well. Reviews that end without a verdict went from 0.79% to 0.27%, and security reviewer retries from 3.5% to 0.04%.

Where this leaves us

An average review now costs $0.77 instead of $2.43, and the median one finishes in 1m 32s instead of 4m 9s. The biggest single saving came from checking what actually reached the provider on each session’s first request, and finding a way to order those messages in a way that was as consistent as possible across commits, merge requests and repositories. The remaining cost savings came from relentlessly experimenting with different models and effort mixes, while making sure we put any preconceived bias for particular models aside.

Lower cost reviews didn’t automatically mean worse quality, but it didn’t automatically mean fine either. Code quality at high effort finds about as many real problems as before, with much less noise and far fewer inflated severities. Performance lost real findings at medium effort, and security may have, too, so testing both at high effort is next. If you run agents at any kind of volume, the two things we’d check first are whether each session’s first request actually reads from the cache, and whether your reviewers still find real problems at the effort level you’re paying for.

If you’re at Cloudflare Connect in San Francisco, I’m talking about how we built the reviewer instead of buying one in my session, It’s time to build, not buy, on Tuesday, October 20 at 12:30 PM PDT. I’ll also be in the Speaker Connection Lounge from 1:10 PM if you want to ask about any of the numbers in this post.

Former OpenAI engineer Abdulrahman Alfozan was recently arrested and charged after a hidden recording device in one of OpenAI's offices was traced back to him. The engineer was in frequent contact with a member of the Saudi royal family, who was trying to recruit him to work in Saudi Arabia, but Alfozan had refused, saying he wanted to collect the company stock he had been promised. The Saudi government has offered to pay his bail, and a member of the Saudi military paid for his wife and infant son to fly out of the US the day after his arrest.

The latest use case for AI? Dumbing down your smart TV to get rid of the bloat. A number of developers and vibe coders have recently been sharing solutions for “vibe-coding” your TV to get rid of sponsored ads, speed up the app launcher, redesign the home screen, disable tracking features, and more.

One such solution, called “dumbtv,” describes its mission on its GitHub page thus: “Your TV should do what you paid for: your apps, your HDMI inputs, and nothing else. No ads from the TV itself, no watch tracking, no update you did not ask for.”

Another, “cleanyourtv,” promises to strip the bloatware from any Android TV or Google TV over Wi-Fi, to replace the launcher with one that resembles Apple TV.

While hacking consumer electronics devices to gain more control over their systems is hardly a new idea, the latest advances in AI technology have made such efforts much more accessible to anyone. With smart TVs in particular, the hacks come at a time when people have grown frustrated with being forced to watch ads and put up with their devices surveilling their viewing habits.

Modern smart TVs ship with a technology called automatic content recognition (ACR), which identifies what’s playing on the screen using screenshots, audio clips, or other forms of digital fingerprinting.

If these “dumb TV” hacks become more popular among everyday consumers, they have the potential to disrupt the smart TV ad industry, which profits from selling viewing data to advertisers or using it to display personalized ads on their own interfaces.

As the creator of cleanyourtv, Gathin T., puts it, the idea to clean up the smart TV interface started one afternoon when he got tired of seeing the ads on his parents’ TV set.

Vibe coded my parents' TV this afternoon!

It was showing a sponsored ad before you could even get to Netflix.

Gave Claude Code the model number, it found the TV on wifi, removed 25 Xiaomi packages and wrote a new launcher.

Looks like an Apple TV now lol

“I had Claude Code clean it up over Wi-Fi and build a simple home screen with just their apps on it. I put the prompt on GitHub, tweeted the before and after, and a few thousand people did the same to their own TVs over the next two days. Xiaomi, TCL, Sony, Fire TV, LG, a projector or two,” the developer wrote on a website for donations, linked from the project’s homepage.

The solution doesn’t require gaining root access to the TV, nor does it make it impossible to return to the factory default state, if desired.

Meanwhile, the dumbtv solution has been tested end-to-end on a Fire TV Edition television set and Android/Google TV platforms on TVs from Sony, TCL, Philips, Hisense, Xiaomi, and Shield. To use this hack, the developer, Muzzammil Yasin Sabuwala, suggests pointing your preferred AI agent at the dumbtv repository on GitHub.

Sabuwala said he was motivated to work on dumbtv because he was tired of the ads and not being able to delve directly into the content he wanted to watch. His solution was coded using a combination of Deepseek V4.1 Flash, Claude Opus 5.5, and Claude Sonnet 5.5, he told TechCrunch, and he plans to maintain the GitHub, adding support for more models over time.

introducing dumbtv

– no spying

– no ads from tv

– fully customisable

to setup just point your agent to this repo – https://t.co/prQLD17Wa4

Fair warning: All these solutions are works in progress, and various users are now testing them across different TV platforms and suggesting updates and fixes.

However, individuals don’t need to borrow someone else’s work from GitHub to get the job done.

In one newly viral X post, Ryan Doyle explains that he simply sent Claude Code the listing for his TV and asked “Can you hack this?” The agent then talked him through the process, allowing him to remove the ads and bloatware from the TV set, speed up the lagging user interface, and customize his screensaver, he claims.

Doyle then goes on to demonstrate in a video how fast and responsive the new interface is after the AI made the requested changes.

This is how fast the TV moves now that Claude deleted all the BS laggy bloatware it comes with

Seeing posts about people “vibe-coding their TVs,” inspired one X user, Mihir Gupta, to try it himself.

“One afternoon with Claude Code: 25 bloat apps disabled, the 192 MB stock launcher replaced with a custom 83 MB one, plus rotating wallpapers,” he wrote.

The end result of these hacks may be mixed, however. Some people have found that Claude wouldn’t respond to their simple suggestions to “hack my TV,” necessitating more complex prompts. Others warned that AI agents could make mistakes, possibly disabling important packages or breaking things in the process. One person even said they bricked their Android TV using Claude, and another got stuck halfway through hacking their Fire TV.

For those wary of using AI to fully hack their TVs, there are existing solutions for customizing Android-based smart TVs, such as home screen replacement apps ATV Launcher, Projectivy Launcher, and FLauncher.

Where decisions live

One of the more useful changes I’ve made to how I work has nothing to do with Figma. I’ve become much more deliberate about where different kinds of project information live.

The problem wasn’t that there wasn’t enough documentation. Usually the opposite. There were Slack threads, meeting notes, design comments, tickets, personal notes, and decisions scattered across all of them. Everything existed somewhere, but finding out what had actually been decided was still harder than it should have been.

Agents help with this to some extent. I can ask a question across a lot of context now instead of manually searching every thread. But that only works if the agent has access to the sources, and if those sources contain enough chronology to make sense of what changed when, because a decision without a date can be surprisingly dangerous. Maybe it was made yesterday. Maybe it was made six weeks ago and has since been reversed. Maybe it was a suggestion that everyone discussed but nobody actually agreed to. Search makes information easier to retrieve. It doesn’t automatically make it trustworthy.

So I’ve ended up with a fairly simple model. Slack is for discussion. Meetings are where a lot of things get resolved, and I use Granola heavily because I don’t want to rely on memory for what someone said or why we landed somewhere. Inside each project folder in my private repo, I keep two other files: running-notes.md and decisions.md.

They sound similar, but they do very different jobs. running-notes.md is chronological. It contains observations, questions, things I’ve tried, details that might matter later, and thinking that is still changing. It is allowed to be messy because it reflects the work as it happens. decisions.md is much stricter. It’s the record of where things landed, with the newest decisions at the top. Some of those decisions are team decisions. Others are design decisions I’ve made while shaping the experience and may never need a meeting or Slack announcement.

That separation has been a huge unlock. If I want to understand how we got somewhere, I look at the running notes. If I want to know what is currently true, I look at the decisions. An agent can use both, but the distinction matters, because without it every old thought carries roughly the same weight as a current decision. You end up asking an agent a question and getting back a perfectly sourced answer to something nobody believes anymore.

I think this is one of the less discussed parts of making agents genuinely useful in product work. We talk a lot about giving them more context: access to Slack, meeting transcripts, repositories, design files, tickets. More context is good, but context also needs structure. The agent needs some way to distinguish exploration from commitment, old information from current information, and a team decision from one person thinking out loud.

That is partly why timestamps matter so much. A decision log with dates gives you something close to version history for the product’s thinking. If a decision changes, I don’t delete the old one. I add the new decision above it, which lets both me and the agent see that something changed instead of pretending the previous state never existed. The same applies to running notes, where chronology makes it possible to understand whether a question is still open or whether later work resolved it.

I don’t think every team needs my exact setup. The useful principle is that different places should have different jobs. Discussion can be messy. Meetings can be conversational. Notes can capture uncertainty. But decisions need somewhere durable to land, otherwise the team keeps paying for the same decision twice: once when they make it, and again six weeks later when nobody can remember what they decided.

Agents make that problem easier to solve, but they also expose how much discipline the underlying information needs.

A searchable mess is still a mess.

motion without commotion

Beautiful, Performant, Accessible

Motion made simple, for Tailwind CSS

npm i -D tailwindcss-motion

A new simple syntax animation library. Batteries included. Infinitely configurable.

Open Source / MIT License

Simple interface, infinite configurability

An intuitive syntax — built for movement.

Accessible by design

Animation accessibility is no longer a nice-to-have. We’ve built in accessibility by default.

Performance tested & optimized

No need to worry about browser-compatibility, property calculations, frames-per-second.

Installation

npm i -d tailwindcss-motion

// tailwind.config.js

export default {
     theme: {
        extend: {}, 
    },
   plugins: [require('tailwindcss-motion')], 
};

Usage

Presets

Fade Slide Focus Blur Expand Shrink Pop Shake Bounce Confetti Typewriter Flomoji Compress Pulse Wobble Seesaw Oscillate Stretch Float Spin Blink

Custom Animations

Animator is best experienced on a desktop device.

Build with the visual animator inline, on your site — export the code to Tailwind CSS, Framer Motion, GSAP & more.

ExcaliClaw: the collaborative workspace for hand-drawn diagrams

ExcaliClaw is an independent workspace for organizing, sharing and collaboratively creating hand-drawn diagrams. It runs in the browser, nothing to install.

Features

• Persistent storage: every drawing is saved automatically.
• Collections: organize your drawings into folders and search across all of them instantly.
• Real-time collaboration: share a link, draw together and see live cursors.
• Share by public link or by username.
• Export everything to JSON and import drawings from other tools, such as Miro.
• MCP tools for AI agents (Claude, Cursor, VS Code and more).

Pricing

Free €0, Starter €9/month (up to 5 members), Pro €29/month (up to 20 members), Enterprise on request. Unlimited MCP and AI on every plan.

This clip examines two principles that work hand in hand to make web content readable: the inverted pyramid approach to information order and the use of visual structure to help users scan efficiently. William Hudson, UX Strategist and Founder of Syntagm Ltd, describes the theoretical basis and practical examples of both.

Starting with the Most Important Information

The inverted pyramid is a well-established approach in journalism that translates naturally to web content. Instead of building to a conclusion, you open with a broad summary of what the content covers and add detail as the page progresses. A reader who stops at any point should have the essential message.

The principle is simple in theory but often ignored in practice. Many pages start with background, context, or preamble, burying the actual point several paragraphs down. Online users are unlikely to read that far, especially when they are looking for something specific.

The approach is attributed to Edwin Stanton, Abraham Lincoln's Secretary of War, who is credited with organizing the telegram reporting Lincoln's assassination in 1865. That telegram was reprinted on the front pages of newspapers, including the New York Times, and remains a textbook example of the approach: the reader understands the entire event from the first sentence, with supporting detail following in decreasing order of importance.

Practical Guidelines for Inverted Pyramid Writing

Applying the inverted pyramid to web content means following a few consistent practices:

• Use clear, meaningful headings or lists at the start of each topic.
• Create separate paragraphs for distinct points so each one can stand alone.
• Lead every paragraph with its main idea. Don't save the conclusion for the end of a paragraph.
• Aim for one key idea per paragraph. Multi-point paragraphs are harder to scan and easier to misread.

That last point (one idea per paragraph) comes from the technical writing community and applies equally well to product documentation, help content, and marketing copy. It keeps pages scannable and reduces the cognitive effort required to find information.

AI drafts are worth checking for their inverted pyramid structure. Left to themselves, AIs often build toward a conclusion, burying the main message several paragraphs down, which is the opposite of the inverted pyramid. The flip side is that AI is good at restructuring on request: ask it to put the key message first and lead each paragraph with its main idea, then check that the result still says what you mean.

Visual Structure: Making Pages Scannable

Structuring the order of information is only part of the solution. Visual structure supports scanning by providing clear entry points and navigation cues. The guidelines here overlap with good information hierarchy:

• Use headings to signal topic changes. Readers use headings to decide whether to read a section at all.
• Keep paragraphs short. Long unbroken text blocks suppress scanning and signal effort.
• Use bulleted or numbered lists where items are genuinely parallel. Lists are faster to scan than prose.
• Use bold or italic sparingly to highlight key terms or phrases. Highlighting too much defeats the purpose.

A note on italic text: italics can be useful for emphasis or technical terms, but extended italic passages are harder to read than upright text. Use italics for short runs rather than whole sentences.

A useful test is to look at a page and ask what a visitor could learn in five seconds of scanning, without reading a word of the body text. If the answer is "nothing useful," the visual structure needs work.

What Poor Visual Structure Looks Like

The contrast between a structured and unstructured page is immediately obvious, even without reading the content. A page with three large paragraphs and a generic heading like "Program Overview" gives the reader no entry points. To extract any information, they have to read line by line, which most users are unwilling to do for content they haven't committed to.

The same content, reorganized with descriptive subheadings, shorter paragraphs, and bullet points, becomes scannable in seconds. A visitor can identify the relevant section and decide whether to read further. The information hasn't changed, but the experience of finding it has changed dramatically.

The Take Away

• The inverted pyramid puts the most important information first. Readers who stop early still get the key message.
• Start paragraphs with their main idea, not background or context.
• Aim for one idea per paragraph to support scanning and comprehension.
• Headings, short paragraphs, and lists give pages visual structure that aids scanning.
• Use bold or italic only for short emphasis. Extensive italic text is harder to read.
• Test your page by asking what a five-second scan would reveal. If the answer is nothing, restructure.

Today, we officially roll out MiniMax M3.1 Flash.

Space Bunny 🐰, which processed more than 200 trillion tokens while operating anonymously, was an early version of MiniMax M3.1 Flash.

As a next-generation Flash model, M3.1 Flash delivers a generational leap in agentic tasks, coding, Computer Use and cybersecurity, while making online inference nearly three times faster and reducing usage costs by 70%.

Stronger Capabilities Across the Board

M3.1 Flash improves across a broad range of benchmarks, reaching the level of leading models in complex agentic tasks (cowork), computer use, software development (coding), and cybersecurity.

Complex Tasks and Automation:

• M3.1 Flash ranks among the top performers on AutomationBench-AA. It can complete real enterprise workflows across SaaS systems, solving practical problems in sales, marketing, operations, customer service, finance, and HR from end to end.
• Scoring 76.2 on BankerToolBench, it excels at complex real-world challenges such as multi-step planning, maintaining consistency across documents and files, financial compliance, and chained tool calls.

Coding and Software Engineering:

• It achieves 73.7% on DeepSWE v1.1, placing it alongside top models. DeepSWE focuses on complex software tasks that require models to independently understand code, develop features, fix issues, and validate their work through testing. M3.1 Flash demonstrates strong execution across long sequences of steps, supporting complex software development workflows at a lower cost.

Computer Use:

• It scores 61.7 points on OSWorld V2, which measures AI computer operation and cross-application task execution, and 29.6 points on Agents’ Last Exam (ALE), which evaluates performance on real professional work and complex tasks. It ranks first among Chinese models on both benchmarks.
• M3.1 Flash demonstrates strong capabilities in interacting with real environments, using tools, and executing long sequences of tasks—moving beyond understanding a task to taking action and delivering results.

Cybersecurity:

• It achieves a strong score of 82% on CyberGym, demonstrating leading capabilities in vulnerability discovery and validation.
• In in-depth evaluations by our internal security experts, the model performed strongly in code auditing, vulnerability patching, penetration testing, malware analysis, and reverse engineering, enabling efficient, low-cost support for building complex security systems.

We have further optimized M3.1 Flash’s inference efficiency through more aggressive sparsity. In everyday use, output speeds can reach 200+ TPS (tokens per second), with median (P50) speeds consistently reaching 170+ TPS.

Pricing: Most Cost-Effective

For agentic tasks, the model’s overall usage cost is 70% lower than its predecessor.

Flat pricing per 1M tokens: $0.15 input · $0.60 output · $0.015 cached input.

Redefining Capability and Cost for Agentic Tasks

Across three benchmarks—Automation-Bench for complex agentic task execution, DeepSWE for real-world coding, and Agents’ Last Exam (ALE) for computer use in real-world tasks with economic value—M3.1 Flash delivers performance on par with top models at a very low task cost, setting a highly competitive new standard for performance and cost.

M3.1 Flash is now available through the MiniMax API, M Plan, and MiniMax Code. Model weights will be released later.

Download MiniMax Code for desktop: https://agent.minimax.io/download

Subscribe to M Plan: https://www.minimax.io/m-plan

API access: platform.minimax.io

Flash represents our ongoing exploration of the balance between efficiency and capability. Pro, which pushes the boundaries of intelligence, will also arrive later.

Intelligence with Everyone.

Introducing Exa 3.0

Today we’re introducing Exa 3.0, the largest improvement to search quality we’ve ever released. It ranks first on every benchmark we tested, from public evaluations to coding, finance, and go-to-market intelligence.

We’re also launching Exa Lite, a new search type at $4 per 1,000 requests, built for cost-sensitive applications.

Retrieval improvements

Exa 3.0 leads on evaluations spanning coding, finance, deep research, and company intelligence. The gains come from three improvements to our retrieval stack, and every search type benefits from them:

• Trained a larger embedding model with more compute and data than any previous model.
• Made Dynamic Highlights generally available, using 95% fewer tokens than full page text while improving answer quality.
• Added billions of documents to our index across useful data types like products, local businesses, flights, events, sports, weather, and more.

Exa Lite

Exa 3.0 also includes Exa Lite, our new search type, priced at $4 per 1,000 requests.

Lite runs on the same index as Exa Auto. For higher quality, Exa Auto uses more compute across the retrieval stack, including candidate generation, highlights, and ranking.

For cost-sensitive applications, Lite offers strong search quality at a lower price. Together, Lite and Auto set a new Pareto frontier for search.

Better highlights, fewer tokens

Earlier this year, we released a research preview of Dynamic Highlights.

With Exa 3.0, Dynamic Highlights is generally available at no additional charge. Improvements to model efficiency have made it substantially faster and cheaper to run.

Instead of extracting highlights from each page, our new model selects tokens across all results, giving more to the best pages, cutting repeated information, and using 95% fewer tokens than full page text.

Expanding our index

Exa runs its own crawler and an independent index. It tracks over 2 trillion URLs, serves 100 billion pages, and grows around what our customers search for. We have seen an explosion in usage from personal AI assistants, so we prioritized expanding our index and data partnerships to serve these use cases.

Exa now includes:

• 1.27B ecommerce listings with prices and availability
• 211M+ local businesses with hours and ratings
• Real-time news, sports, weather, and market data
• Flights, local events, transit, and podcasts

This new data adds to the coverage our customers already rely on, including people, companies, code, and publications.

Availability

Exa 3.0 is available today through the API, including Exa Lite, upgraded highlights, and our expanded index. Exa Lite costs $4 per 1,000 requests, Exa Auto is $7 per 1,000 requests, and the improved highlights and expanded data sources are included at no additional charge.

Get started in the API dashboard or read the documentation.

Join our Head of Product Shyam Kumar and Head of R&D Liam Hinzman for a live Exa 3.0 Q&A on Wednesday, October 21 at 1pm PT.

Nscale and Anthropic are reportedly in talks for yet another $45B compute deal

A little over a month ago, Anthropic and AI infrastructure provider Nscale announced a $45 billion compute deal. Now the duo may be about to do it again.

Bloomberg reports that the two companies are said to be on the verge of announcing yet another $45 billion compute deal, citing people familiar with the matter. Those sources cautioned that talks are still underway and that the details could change.

If the deal goes through, it would be the latest in a long string of giant compute deals Anthropic has struck over the past year. TechCrunch reached out to Nscale and Anthropic for more information and will update this story if we hear back.

The massive amount of money being sunk into AI compute deals has spooked a certain segment of investors, who worry that companies are spending too much money for too little profit. Still, Anthropic has pressed on with such partnerships, driven by the belief that it will all pay off in the end.

Both Anthropic and Nscale are also currently pursuing IPOs. Anthropic is still expected to go public this year. Nscale is also seeking to go public, although Bloomberg reported on Monday that the company is experiencing investor pushback over its proposed valuation of $30 billion.

An AI lab that specializes in gathering real-world data wants to partner with homeowners to record how skilled laborers do their jobs to train AI robots. HUMXN said it will subsidize plumbing, electrical, HVAC, air-duct cleaning, and carpet cleaning, allowing people who need these services to get them for free in exchange for letting someone in with “wearable capture technology” work inside their home.

“The next generation of AI is going to need more than text and images from the internet. Robots need to understand how skilled people interact with the physical world. Home-service technicians perform millions of highly technical tasks every day. We are creating a way for homeowners and service companies to benefit financially from the value of that expertise,” HUMXN founder Thomas Unise said.

He also added, “There are millions of skilled workers performing incredibly complex tasks every day, but very little of that expertise exists in a format that AI systems can learn from. We want to build the infrastructure that connects that knowledge with the companies building the next generation of intelligent machines while making sure the people creating the value participate in the economics.”

HUMXN said it’s difficult to capture skilled workers' natural movements in lab settings. By working with homeowners, it could capture data across “different homes, equipment types, problems, technicians, and environments.” It would also give AI models insight into how technicians get the job done—from examining the situation and testing systems to choosing the right tools, responding to changing conditions, and determining whether the job was completed successfully.

The lab says its system would let homeowners get qualifying work done on their property for free while still ensuring service professionals get paid. On the other hand, HUMXN essentially pays residents for the right to record on their premises to gather real-world training data. The company is launching its program in three cities—Minneapolis, Chicago, and Miami—to gather data from places with very different climates. If you live in one of these cities and need something done or repaired at home, you can check whether you qualify on the HUMXN Free Home Service webpage.

HUMXN’s effort to pay for training data is refreshing, after many AI labs, including Meta, Nvidia, and OpenAI, have been accused of stealing data to train their models. But the next generation of AI likely can't be trained on just text, images, and video scraped from the internet, so companies like these may be forced to pay for data generated from real-world activities.

OpenAI reported major improvements in coding and software migration across languages such as COBOL, Fortran, and Visual Basic.

The Scoop

As Waymo expands into new cities with its self-driving cars, the company plans to use the $5 billion it recently borrowed to massively increase its fleet.

The company, which currently has 4,000 cars, is looking to bring its total number to 8,000 by the end of the year and grow to 20,000 by the end of next year, according to people familiar with the matter.

Waymo declined to comment. The company said in a statement on its website that it raised the funds to grow internationally and in the US.

Waymo, which operates in 15 US cities, is also bringing its rides to locations such as Toronto. Waymo recently opened a facility in Nashville in partnership with Lyft to charge, clean and maintain cars.

Waymo has already ordered thousands of cars from China, to help expand its fleet, the New York Post reported. The company has also rebranded versions of a vehicle made by Zeekr, a unit of CCP-linked company Geely Holding Group.

Know More

Waymo recently raised debt for the first time, and it came without guarantees from Alphabet, its parent company. It borrowed the $5 billion from private credit lenders, and the deal allows the company to use its fleet in the future to borrow more by securitizing leases.

The world’s first demonstration of a subsea geothermal power plant has taken place near an active underwater volcano almost a mile below the ocean surface. It generated less than 10 seconds of net-positive electricity but showed the technical feasibility of tapping another form of renewable energy underwater.

The three-week test deployment of the 3-ton prototype power plant took place at the Axial Seamount in the northeast Pacific Ocean in September. Endurance Energy, the Seattle-based startup behind the effort, aims to eventually commercialize subsea geothermal power for Pacific island nations and other customers looking for alternatives to importing expensive fossil fuels.

“The deep ocean gives us unlimited cold seawater for cooling, and its weight keeps the system and the well pressurized, so our plants can be compact,” said Andrew Redd, founder and CEO of Endurance Energy, in an email to Ars.

But efforts to tap geothermal power on the seafloor face many different challenges from land-based geothermal projects, which can also add up to higher installation and operational costs. So Endurance Energy must demonstrate consistent underwater operations as well as prove the approach can be cost-effective.

“It’s probably technically feasible, but it would undoubtedly be more expensive than to do it on land,” said Roland Horne, professor of energy science & engineering at Stanford University, in an emailed response to Ars.

Deep sea drilling

Endurance Energy’s deployment required a subsea lander drill to deploy from the ship Ocean Guardian—operated by Stabbert Maritime—and drill two holes in the seafloor at a depth of about 5,000 feet (1,524 meters). That means the test took place at a depth exceeding 2.5 times the height of the One World Trade Center building in New York City, which is the tallest building in the United States.

Both the drilled holes started venting hot hydrothermal fluid measured at a temperature of about 500° F (260° C). The Endurance Energy team proceeded to case and cement the second hole before installing a valve to create a well.

Next up, the company deployed its 100-kilowatt power plant, named Adélie, that is designed to vaporize incoming hydrothermal fluid to spin a turbine and drive an electric generator. It used the assistance of Canada’s remotely operated submersible ROPOS to help connect the power plant to the newly drilled well.

Adélie also connected to Endurance Energy’s Seattle command center by plugging into the Regional Cabled Array, a 559-mile (900-kilometer) network of undersea fiber-optic and electric cables that provides both power and connectivity to scientific sensors on the seafloor. The undersea network is funded by the US National Science Foundation and is operated by the University of Washington.

That all set the stage for the Adélie power test. But a major hitch soon arose—the drilled well extending 52 feet (16 meters) down into the seafloor was not delivering enough of the hydrothermal fluid to run the power plant.

“For our first well, the goal was to show we could drill, case, cement, and cap a well on the seafloor, so we kept it small and shallow,” Redd explained. “That limited how much fluid it could deliver, and deeper wells should change that.”

The test well was also just 2 inches (5 centimeters) wide, compared to oil, gas, and onshore geothermal wells that typically have casings 20 to 36 inches (51 to 91 centimeters) across.

Endurance Energy plans to avoid this issue in the future by drilling deeper wells to access more fluid. The company’s current lander drill can reach about 260 feet (80 meters), which would be five times deeper than the initial test well.

Powering on

To try running the Adélie power plant anyway, the team redeployed it to a nearby natural vent where hydrothermal fluid was already flowing out at about 538° F (281° C). On September 27, they gave it a try.

Over nearly half a minute, the power plant turbine reached about 26,000 rpm and enabled the generator to produce 60 watt-hours of electricity.

The power plant also became net-positive by producing more electricity than it consumed for about 8.7 seconds. It produced a median of about 2 kilowatts of net power and peaked at 16.5 kilowatts of net power.

“It’s the proof point,” Redd told Ars. “Net-positive is the threshold that matters: the plant made more power than it took to run itself on the seafloor, which no one had done before.”

But then a software issue brought the power run to a halt. Before the generator takes over, Adélie first relies on a battery to run its pumps, thrusters, and controls, along with spinning the turbine to get it up to speed, Redd explained. A battery module recorded a brief spike in current during the spin-up process and then stopped reporting.

That prompted Adélie’s software to automatically stop the power plant as a safety precaution, because it kept relying on the old reading from the battery module.

When the team was restarting the power plant, a power cable feeding the refrigerant pump also failed when an imperfection in the cable casing allowed seawater to seep in and short two of the electrical conductors. That ended the trial run, although Endurance Energy already plans to use the experience to improve how it builds and tests subsea cables.

Future deployments

Placing the geothermal plant on top of a natural hydrothermal vent was a one-time test for purely research and demonstration purposes, Redd said. His company still plans to rely on drilled wells in future deployments.

Endurance Energy also described taking steps to reduce potential environmental impacts on the seafloor and marine life. The team described choosing the “least disruptive” site for the test run and continuously monitored the process by sampling the water and recording the seafloor array of tubeworms, snails, crabs, and bacterial mats. It also checked findings against scientific sensors run by independent researchers and sent water, rock, and mineral samples for independent lab analysis.

The company’s next trial run planned for the winter of 2026—2027 will involve a refurbished and upgraded Adélie—renamed Gentoo in keeping with the penguin-inspired naming—that will aim to sustain higher power generation.

The company is also developing a larger 2-megawatt commercial generator for its first planned commercial deployment with the Kingdom of Tonga in 2027. The Polynesian island nation in the South Pacific Ocean runs its power grid primarily on imported diesel fuel, which has significantly increased in price since the United States and Israel launched their war with Iran.

“The 2 MW commercial generators will be about the size of a shipping container, and we are deploying up to six of these generators [to] offshore Tonga,” Redd told Ars. “The physical footprint of this project will be relatively small.”

Geothermal energy projects are already cost-effective on land but “on the edge of competitive pricewise,” said Horne at Stanford University. So he cautioned that any factors making geothermal more expensive would “push it to the noncompetitive side.”

Still, other customers may consider Endurance Energy’s approach if the company can demonstrate reliable operations over time with the Kingdom of Tonga. The skyrocketing cost of imported fossil fuels is a huge factor that has already spurred multiple governments to invest in more renewable energy alternatives.

“Large markets with ample offshore geothermal resources include the United States—Pacific Northwest and Alaska—Taiwan, and Japan,” Redd said. “As the technology matures, we expect to compete on cost and deliver continuous, weather-independent power to utilities and large energy users.”

AI will not automate radiologists like you think

We have been talking for years now about AI automating jobs. Radiology has been a prime target, with Geoff Hinton once claiming, “people should stop training radiologists now, it’s just completely obvious that within five years, deep learning is going to do better than radiologists”, which is funny since he said that in 2016. There is now more demand for radiologists than ever, so clearly things did not turn out the way many thought. Here I will make a prediction that while radiology will change in the coming decade, radiologists will not be automated away any time soon. I will use radiology as an example but I think these principles will broadly apply to any field where demand can be elastic and quality can scale with increased intelligence.

First of all, we have seen in the short history of language models that there is a “jagged edge of intelligence”, where AI excels at verifiable tasks with a lot of data but is underwhelming on less common tasks. One thing most AI researchers underestimate about radiology is that it is actually extremely multi-task. There are at least a hundred conditions that can be diagnosed from x-rays alone, and thousands using CT and MRI. AI will first master common and easy-to-see conditions and it will not be as good as experts at less-common diseases just because there is less data for that. This jagged edge will certainly improve over time but this means that AI will certainly be used as a triage tool at first, rather than full automation in one go. I would guess that this process from solid triage tool to full automation would take 3-5 years in the best case scenario, because training AI to get all the edge cases right will be bottlenecked by data collection of rare diseases, and also because radiology isn’t currently a focus for frontier labs.

Second, there will be elastic demand for radiology as it gets cheaper per unit. I think elastic demand (“Jevons paradox”) is the most underrated phenomenon when people think about AI automation. In software, it is obvious that I have way more demand than before because Claude Code makes it so easy. These days I ask Claude Code to build a custom three-thousand line html viewer to help me visualize every little RL run that I do. The same thing will happen in radiology. If there is essentially no cost or latency of interpreting an MRI, a physician can order many scans preemptively to better diagnose a case. So with AI tools, a radiologist might have to read only 20% of inbound scans, but there might be 5x more scans inbound. Many developing countries have fewer than one radiologist per million people and they will also want to send a lot of radiology to be interpreted.

Longer term, cheap and fast radiology interpretation will also drive incentives to build cheaper radiology scanners. If an MRI had essentially no latency for interpretation, medical devices companies will want to build much cheaper MRI machines that can be used more frequently, perhaps even in the middle of a surgery. AI will accelerate the development of scanning technology, too. If a full body MRI was only $100 dollars I would totally want to get one every month instead of every two years. I can imagine a world where people get 10 or 100x the number of scans they do today, largely for preventative care, if radiology were 10-100x cheaper.

Third, even if we did have a model that could outperform the world’s best radiologists today, that would not be the end of all work on radiology. Medicine is a field of change. We may develop new treatment protocols that require reading radiology images in a way that radiologists currently aren’t used to. New scanners may reveal diseases that we cannot currently diagnose today with radiology alone. Some radiologists will change their work from reading scans to doing frontier research to advance our understanding of radiology and translate new knowledge into updated models.

Moreover, I am sure that we will ask for more out of our AI models than ever before. With a good flywheel, we may one day train AI models that can use radiology images to predict disease probabilities far into the future. With good prediction algorithms, cancer may be detected months earlier than we can detect it now. Society will invest a lot into this research and this will contribute even more to increased demand for radiology and the best AI around it.

On top of all of this, the medical system is typically slower to adopt new technology and has more regulation compared to technology companies. There is legacy infrastructure and medical centers need to constantly support patients which makes it hard to integrate new technology. This is even more true in developing countries. Moreover data access tends to be limited due to HIPAA, deidentification, IRBs, etc. So I think radiologists will be in demand for a while.

While some worry about radiology being totally automated, I think there is a more exciting future for radiology than ever before—one where there is more demand and we ask for more predictive power from our intelligence. This is similar to how many of us feel that programming will thrive more than ever before despite drastic change in the field. More generally, any domain where demand can be elastic and quality can scale with increased intelligence will, like radiology, similarly flourish with the development of AI. This is certainly a more exciting and nuanced future than what Hinton described in 2016!

(Finally, to be fair to Hinton, he did acknowledge in a recent podcast that he was wrong and also agrees with the elastic demand argument.)

Thanks Jason Rothschild and Engy Ziedan for feedback on this essay.

Replit, the AI coding platform that has become a favorite of startup founders and developers, is no longer working with Anthropic, the company’s CEO and co-founder Amjad Masad said Thursday while onstage at TechCrunch Disrupt.

Masad said the decision was made for a number of different reasons, including cost. Replit announced a partnership with OpenAI in August, but there was never any indication that it was no longer partnering with Anthropic.

“I think ChatGPT is better now,” Masad said, adding that the company uses an internal benchmark to help assess metrics like performance. “We publish a public benchmark as well, and consistently, Sol and Astra perform better on building vibe-coded applications from scratch. It was a decision based on both cost, partnership, and performance. And for all these reasons, we just felt like they were a better partner for now.”

It seems, however, that Anthropic hasn’t been completely cut out of Replit, which sells a cloud-based software development platform where users can develop and deploy apps directly from inside their browser.

After Disrupt, Masad clarified that customers can still access Anthropic models on the platform, but that OpenAI’s ChatGPT is now the default. This shift could significantly reduce Replit’s spend with Anthropic since most customers stick with the default rather than selecting a model themselves.

Prior to striking a deal with OpenAI, Replit relied on Anthropic’s Claude models to run its platform. That partnership was said to have helped the company grow its revenue significantly, and Masad noted onstage that Replit had been, until recently, a top-five customer of Anthropic’s.

“Replit remains model agnostic,” Masad told TechCrunch over the weekend. “Our users can choose Anthropic’s Claude or other supported models … OpenAI is now our preferred partner for powering Replit Agent, based on performance, economics, and the strength of our partnership.”

However, Masad’s comments onstage were rejected by insiders familiar with the partnership between Anthropic and Replit. One person familiar, who asked not to be named, said the partnership was still in place.

There is evidence on the company’s website, blog posts, and social media posts that Replit was promoting Anthropic products as recently as a few weeks ago. For instance, a blog post in late September cites Anthropic’s Claude Fable 5 and Claude Fable 5.1 as models running in Replit Agent’s production environment. Around the same time, one of Replit’s product employees posted on X about using Anthropic’s flagship model Opus 5.5 and promoting its capabilities.

Masad also shared insights about the company’s growth while onstage at Disrupt, noting that enterprise is starting to provide a larger slice of revenue.

“We’re not sharing ARR numbers just yet, but in terms of growth, like, I would say, enterprise was like 2% of revenue last year,” Masad said. “This year, I would say like 15% of our revenue is enterprise contracts, and more than 50% of our revenue is B2B.”

Backstage, Masad told TechCrunch that he expects more than half of Replit’s revenue to come from enterprise and government customers in 2027.

Masad also commented on the necessity for good AI safety measures.

“In the same way that us humans need a certain environment to work — you need a nice office, maybe nice good food in the office, air-conditioning, computer — agents need a habitat for them to exist and do good work,” he said. “So that habitat has good orchestration, good error recovery, good safety and security and sandboxing, good networking, good identity and authorization. And once you figure all of that out, then you can deploy AI safely.”

This article was originally published on October 16 at 2:22 p.m. PT. It has been updated to include more context around Replit’s partnerships with Anthropic and OpenAI. Its title has been updated, as well.

Product designer no longer describes a single job, so four attributes (Style, Strategy, Builder, and Operator) offer a shared vocabulary for candidates and hiring managers. Craft is the floor beneath all four. Most strong designers lead with one or two.

Digital products increasingly translate human behavior into metrics such as sleep scores, ratings, streaks, story points, and follower counts, which can gradually influence how people understand themselves and behave. These measurements expose only selected parts of reality, yet their apparent objectivity can give them greater authority than unmeasured experiences, relationships, and intuition. UX designers therefore shape more than interfaces and experiences: by deciding which metrics products emphasize, they influence how people perceive themselves and should deliberately leave room for realities that cannot be quantified.

Full article content is not available for inline reading.

Read the original article →

AI's impact on national security and economic trajectories marks the onset of the singularity, accelerating scientific and technological progress. AI systems like Claude, ChatGPT, and Gemini are already solving complex problems in disciplines like mathematics, biology, and robotics, indicating potential for widespread innovation. To capitalize on these advancements, there needs to be significant infrastructure development and careful governance to navigate the associated risks and ensure equitable benefits.

Office Intelligence explores how AI agents can use evidence, create useful work artifacts, and carry knowledge across tasks. The project focuses on environments, datasets, and learning methods for sustained knowledge work.

Gemini Notebook offers tools to create slides and videos with AI-driven design suggestions.

Netflix is overhauling its creative leadership as it struggles to get domestic audiences to watch more.

It's okay to enjoy things without any economic justification.

Microsoft's redesigned Photos for Windows 11 adds a new Gallery, Editor, and Viewer, rolling out first to Windows Insiders, with wider availability planned later in 2026. Gallery merges local, OneDrive, and iCloud photos with natural-language search, while the Editor groups tools into Crop, Enhance, Repair, and Stylize.

WhatsApp is testing sound stickers on Android that let users attach up to 10 seconds of recorded or existing audio to custom stickers, while video-based stickers can retain five seconds of their original sound. Another option removes the outline around custom stickers for a cleaner appearance. A redesigned two-line compose box is also being tested, separating the typing field from additional controls to create more space and accommodate future shortcuts.

Fulham F.C's refreshed identity by Music and F37 Foundry is built around FFC Original, a bespoke typeface inspired by hand-rendered lettering discovered inside Craven Cottage, London's oldest football stadium. Rather than placing historical references alongside a contemporary identity, the system uses the club's physical heritage as the source of its modern visual language. The typography now extends across matchday graphics, campaigns, retail, moving image, and a 2026/27 away-kit campaign inspired by the visual language of the 1990s.

NN/g's UX Maps glossary defines and distinguishes common mapping tools.

With approximately 73 million children under the age of 18 living in the US, that could mean giving away nearly $11 billion in stock.

Sihoo's self-adjusting H300 Pro and Doro C300 Pro V2 chairs, which have lumbar support that adapts to posture shifts, will be shown at ORGATEC 2026 in Cologne.