We are sharing the first complete computer-checked proof of Fermat’s Last Theorem. Claude worked largely autonomously over 11 days to write the proof in the Lean programming language. Below, we describe how the formalization was done and share some thoughts about what this work could mean for research mathematics.

Around 1637, Pierre de Fermat jotted down a claim in the margin of his copy of Diophantus’s Arithmetica that would become one of the most famous mathematical conjectures of all time: no positive integers a, b, c satisfy aⁿ + bⁿ = cⁿ for any n > 2. Fermat’s Last Theorem (FLT), as the conjecture became known, turned out to be incredibly difficult to prove. The first proof, from Sir Andrew Wiles in 1995, ran to 129 pages and required months of painstaking work to verify.

A decade later, Dutch computer scientist Jan Bergstra proposed “formalizing” Wiles’s proof: converting the mathematical reasoning into a form computers can check automatically. Since then, mathematicians have been developing the methods needed to encode such a complex proof, including a multi-year community effort kicked off in 2024 by Kevin Buzzard at Imperial College London to complete the formalization using the Lean proof assistant.

Recently, Tianyi Peng, an Anthropic researcher whose group at Columbia University builds tools for AI formalization, set out to test whether Claude could make progress on formalizing FLT.1 The result went further than he expected. In 11 days, working largely autonomously, Claude produced the first end-to-end, computer-checked proof of FLT. Along the way, it wrote 13 million lines of Lean and proved 29,500 intermediate theorems.

We shared the resulting proof with Kevin Buzzard, who said:

This extraordinary autoformalization achievement, which Anthropic researchers say only took 11 days, proves Fermat’s Last Theorem with no assumptions other than the axioms of mathematics. Along the way we see autoformalization of algebra, harmonic analysis, geometry and number theory, and we learn that AI autoformalization artefacts are now robust enough to be built upon; the proof is multi-layered.

Automatically formalizing a proof as complex as FLT is a significant step towards a future in which all of mathematics can be readily checked. As AI produces ever more proofs, the ability to easily formalize work can lighten the burden of evaluating new results (a process that can take years). We are hopeful that it will become easier, not harder, to trust the body of knowledge upon which mathematics is built.

The challenge of verifying mathematical proofs

Unlike recent AI-driven work on the Riemann hypothesis, which produced novel mathematics, what’s novel here is the verification—checking a mathematical proof as one would check a mathematical computation with a calculator. Proving math theorems requires assembling complex logical chains, and if a single link is broken, everything that follows it might turn out to be false. Understanding a novel result deeply enough to be confident in its correctness can take months, or even years, of work.

Fermat’s Last Theorem is an illustrative example.2 Fermat wrote down the theorem’s statement in the margin of a book, alongside a tantalizing note:

I have discovered a truly marvelous proof of this, which this margin is too narrow to contain.

For over 350 years, generations of mathematicians searched for a proof of FLT, marvelous or otherwise. In 1908, a prize of 100,000 German gold marks (the equivalent of 1–2 million dollars today) was announced for anyone who could produce a correct proof, and 621 incorrect attempts were produced in the first year alone.

In June 1993, Wiles presented what he believed to be the first correct proof of FLT in a three-day series of lectures. Two months into an intensive verification effort by several mathematicians, a reviewer asked Wiles a question that exposed a critical gap. Wiles spent a year trying to fix it, first alone and then with his former student Richard Taylor. He was on the brink of abandoning the project when he finally realized an approach he’d discarded earlier could fix the proof.

Wiles published the first correct proof of FLT in May 1995; it relied on modern mathematical techniques that were far beyond what would have been known to Fermat in 1637. Since an elementary proof has not been found after centuries of trying, the mathematical community now believes Fermat’s own original “marvelous proof” was incorrect.

Formalizing Fermat’s Last Theorem

One way to check a proof’s correctness is to ask a computer to do it. Proof assistants like Lean verify the logic of a proof algorithmically, demonstrating its correctness beyond a doubt. The difficult part for humans is rewriting the proof so Lean can understand it. While a proof written for human readers will skip many obvious steps, Lean needs to see every step, no matter how trivial. Human proofs also build on centuries of published work, while a formalization starts from the tiny fraction of math that’s been formalized already.

For FLT, the formalization process was expected to take years. Just the blueprint the mathematical community has been using to describe the initial phase of the project runs to 86 pages.

Claude completed the proof in 11 days, producing computer-verifiable proofs of 30,300 theorems along the way (using 29,500 in the final proof). Dozens of Claude agents collaborated to define concepts, prove intermediate theorems, and use those theorems to prove ever harder statements. At 13 million lines of Lean code, Claude’s proof is over 5x the size of Mathlib, the principal community library of mathematical proofs this theorem builds on.3

Claude’s proof follows a simplified version of Wiles’s proof from Darmon, Diamond and Taylor. Mathematical input from humans was limited to occasional high-level instructions from Tianyi: “Jacobian as a scheme sounds high priority,” “push [the] Mazur [theorem] to be done soon.” You can find excerpts of Claude’s thinking here.

“THE FLT root reads Proved on the site. Historic moment (modulo re-check).”

“!!! The FLT ROOT 62eb32c0 reads PROVED. R = T closed and cascaded to the root. This is the campaign's goal: e2e FLT on prove2me.”

“🏁🏁🏁The FLT root reads PROVED on prove2me at 02:00:57Z Aug-18 (10:00:57pm ET Aug-17). Historic moment for this campaign.”

Excerpts of Claude’s thinking as it realizes what it has just accomplished.

A number of Claude’s initial attempts failed: while agents had some early success, they quickly lost track of the project’s state and stopped collaborating effectively. Their failed efforts contributed ~7% of the non-boilerplate lines in the final proof.

The effort succeeded when we switched to using Prove2Me, an open collaborative platform for formalizing mathematics designed by Tianyi Peng and his collaborators at Columbia University. Prove2Me helped by:

1. Maintaining a directed acyclic graph (DAG) of theorem statements that agents used to decide what proofs they should attempt next. This was particularly helpful for mitigating memory degradation and allowing multiple agents to work in parallel.
2. Speeding up Lean compilation and minimizing resource consumption by separating theorem statements and proofs into different files, with the links between them maintained independently.
3. Enabling search and reuse by maintaining a natural-language description of each theorem statement, resulting in a simpler proof path.

Key milestones from the Prove2Me plan that Claude used to formalize Fermat’s Last Theorem. The three colored sections correspond to three core sub-theorems that Claude had to prove on the way to its final goal. This graph closely follows Wiles’s original proof.

With Prove2Me and a Claude Code-based multi-agent harness, a team of agents completed the proof in a little under two weeks, consuming about six billion output tokens from a general-purpose internal research model roughly comparable to Claude Fable 5.1. The finished proof was checked by Lean; it uses just Lean’s three standard axioms, and a comparator confirmed that the theorem’s statement matches Mathlib’s own statement of FLT.

Reducing the burden of formal verification

The speed with which we were able to produce this proof demonstrates that it is now possible to formalize large swaths of mathematics, which may both catch errors in the common body of mathematical proofs and reduce the burden of refereeing new work. After reviewing Claude’s Lean proof, Kevin Buzzard told us:

If the automatic formalization of FLT is possible now, then we have taken a big step towards automatic formalization of the modern mathematical literature. Such autoformalization techniques will lead to new tools, rooting out errors in the current mathematical corpus and lightening the load of referees. The techniques will also enable us to rigorously check LLM-generated mathematics, which is currently typically an extremely costly human-led process.

Formalization is also a major factor in how humans can gain confidence in AI-generated mathematical results. As AI and AI-assisted mathematicians produce more (purported) proofs than ever before, AI-assisted formalization takes part of the load off human reviewers. We expect it will become common to produce a formalized proof alongside any write-up intended for a human reader. Although we do not think a formalized proof should replace a human-understandable exposition, it may be the only feasible way for the mathematical community to keep up with AI-generated contributions.

Writing Lean also seems to help Claude prove novel results. Many of our recent Claude-authored results have been formalized in parallel with their proofs, and Claude appears to use these partial proofs to independently check its hypotheses much like it writes numerical simulations to check that it’s on the right track.

Formalizing FLT was a token-intensive project, but it is also the largest Lean proof ever constructed. Anthropic researchers did a small experiment using three personal Claude Max plans to formalize applications of the Hardy-Littlewood Circle Method. Collaborating entirely through Prove2Me, the agents jointly completed a formalization of Vinogradov’s Three Primes Theorem in just three days. We think with the right scaffold, collaborative formalization of major results with consumer AI subscriptions is achievable.

To this end, Anthropic as well as other labs have recently expanded their support for external researchers—including mathematicians working on pure math and formalization—with free and discounted subscriptions and research credits. We also offer dedicated grants for larger scientific projects, which could include formalizing other major theorems or improving Lean or Mathlib.

With AI rapidly changing what it looks like to do math research, mathematicians—at Anthropic and elsewhere—are grappling with what that means for their work. Formalization, however, is a place where we feel unambiguously good about the role of AI. As formalization becomes a more commonplace tool, we are hopeful that it will help maintain trust in the common body of mathematical knowledge.

Acknowledgments

Our formalization effort is a small piece of the long history of Fermat’s theorem and the development of formal mathematics. The first full proof from Andrew Wiles together with Richard Taylor was a culmination of more than three hundred years of mathematics, integrating ideas from Gerhard Frey, Jean-Pierre Serre, Ken Ribet, Barry Mazur, Robert Langlands, Jerrold Tunnell, Yutaka Taniyama, Goro Shimura, and André Weil, among others. Claude’s proof follows the exposition by Henri Darmon, Fred Diamond, and Richard Taylor.

Our proof adapts pieces from the Imperial College London FLT project led by Kevin Buzzard and the flt-regular project. Lean and Mathlib are both their own labors of love and have received contributions from hundreds of mathematicians, many working with the Lean FRO. We thank Kevin Buzzard for reviewing the proof and for his comments.

Footnotes

1. During his undergrad, Peng’s research advisor wanted to include results from Peng’s thesis in a Nature article. He asked Peng whether he was sure the proof was correct. Peng’s honest answer was: “I'm 99% sure, but it's hard to be 100% certain about a proof this long.” Peng missed out on getting his work published in Nature.
2. There are numerous other stories of the mathematical community struggling with verification. Among the most famous is Thomas Hales’s 1998 proof of the Kepler conjecture, which spent four years in review before a 12-referee panel settled for “99% certain” (Hales eventually led a twenty-person project, Flyspeck, that formalized the proof). Grigori Perelman’s 2002 proof of the Poincaré conjecture took the community roughly four years and three 300-page expositions to accept. Harald Helfgott’s 2013 proof of the weak Goldbach conjecture is still under review. Sometimes results that turn out to be wrong are accepted for years, and other mathematicians build their theories on these faulty foundations.
3. This is partly because Mathlib is concise and well-reviewed, while our proof is likely much longer than it needs to be.

From the very beginning of this recent obsession with identifying everyone online (yes, they like to call it “age” verification, but it always ends up as identity verification), we’ve been pointing out that it was a huge privacy nightmare waiting to happen. Or maybe it wasn’t waiting. Maybe it was already happening.

This week a massive new data breach has been revealed that should put the nail in the coffin for the idea that any sort of age or identity verification could be safe. 153 million scans of drivers licenses easily available based on this breach, with more being added all the time. Literally on the day it was revealed (and right before the site was taken down) it added another 400,000 records to its available database.

There is no safe age verification. There is no age verification that doesn’t put people at risk.

Last year, Eric Goldman wrote the definitive piece on how all of these technologies — no matter what they tell you — are huge privacy risks, but people are still living in denial. This is despite the numerous examples we’ve had in just the past few years of verification providers and their customers having massive data breaches.

The latest comes to us via Brian Krebs, who reports on a massive breach of scanned IDs — more than 153 million drivers licenses from people across the US and Canada, now for sale on the dark web:

A new identity theft service launched on the dark web this week is selling digital scans of more than 153 million drivers licenses from people in the United States and Canada. Based on interviews with individuals whose licenses are available for purchase on this service, it appears to be siphoning images collected by a widely-used identity verification company based in Louisiana. KrebsOnSecurity also has learned that the New Orleans field office of the Federal Bureau of Investigation (FBI) today launched an official inquiry into the source of the images.

Krebs traces the breach back to an ID verifier that appears to be used by many companies, including Hertz, the rental car company. It appears to not be limited to them either, as he checked with a number of people who were in the database, and by looking at the date they were added alongside their calendars, found examples of other people who shared their ID at places like a pot dispensary.

That company turns out to be IDScan.net, based in Louisiana, which has contracts with thousands of dispensaries, not to mention Hertz, FedEx, and Target. And while Krebs is focused on how many of the leaked IDs are connected to real world businesses, it’s worth noting that IDScan.net is also doing age verification for a bunch of tech companies, has a page tracking state age verification laws and company implementations, and even has written positively about laws like KOSA, the Kids Online Safety Act, that would effectively require age verification.

So, yes, we have a company that is a big player in the age verification space, talking up age and identity verification laws, that appears to have had a long-standing ongoing leak of every ID it scanned.

Yiiiiiikes.

And, of course, like all age and identity verification providers, IDScan has spent years talking up how secure it keeps all this data, even as every single record appeared to be leaking in realtime. Here’s their “Trust Center” page which is still up days after the hack was revealed:

That’s the company that spent over a year leaking 150 million drivers licenses in real time, explaining “how we protect data, maintain system reliability, and earn the confidence of our customers and their users.” Might be time to update that page.

But also, this should be a massive warning to everyone pushing for age verification laws. You can have a “trusted” company in the space who brags about all the certifications it has. It’s in “compliance” with the GDPR, the CCPA, and every other law. It is “transparent” about its “privacy practices” and how its “sensitive identity data is handled responsibly” and…. for over a year it’s been leaking all of those sensitive records.

And it appears no one internally at the company noticed.

As Krebs makes clear, the breach included many, many millions of records and ID scans that were being swiped in real time by the hackers who breached the system:

The people behind Nexus claim the license images are coming from an active breach at “a major identity verification company” whose customers include multiple Fortune 500 companies.

The record totals listed by the Nexus identity theft service. The number of drivers license records increased by nearly 400,000 in the span of just 24 hours.

“We have been continuously exfiltrating new data for over a year into our private database,” the service enthused in its introductory post on Exploit. “Records are available to preview before purchase with pertinent information redacted. Customer photos are displayed if available.”

Indeed, over the past 24 hours, the number of drivers license records listed as available in Nexus has increased by nearly 400,000, suggesting that freshly stolen license data is being harvested and uploaded to this service on a semi-regular basis.

And the exposed records aren’t just random members of the public. Krebs found the driver’s license of the sitting Secretary of Defense sitting in there for sale:

A bargain! Only $100 to get a scan of the Secretary of Defense’s driver’s license.

Anyway, each time we highlight a breach people play it down and insist that mandating age verification is perfectly safe and nothing to worry about. Yet here’s one of the largest identity verification companies in the country, with a pipeline so wide open that hackers had a real-time feed of every government ID it scanned, for over a year, without anyone at the company noticing.

Krebs spoke to a security researcher at Cybera, named Larry Baldwin, who talks about how this kind of data can do real damage:

Baldwin said the Nexus identity theft service presents multiple serious security and privacy threats, noting that state-issued drivers licenses are commonly used as proof of one’s identity when opening new lines of credit. Baldwin said the service could also dangerously expose many people who do not wish to be found but who cannot meaningfully change their appearance (or at least not enough to fool today’s AI-based image matching tools).

This category of people, he said, includes those fleeing domestic violence, and even people who have been assigned a whole new life and identity as part of the federal government’s witness protection program, which is generally reserved for criminal defendants in racketeering and conspiracy investigations who agree to cooperate with federal authorities.

“Just when it seems like we’re making some headway in improving authentication controls through drivers license verification systems, this happens and the very thing those improvements are dependent on are compromised,” Baldwin said.

At this point, anyone still supporting age verification requirements, especially claiming it’s for “child safety,” should have to answer for all the millions of people put needlessly at risk due to data breaches like this.

You cannot do age or identity verification safely. It always creates some sort of record and that set of records will always become a target. That’s what happened here. And it’s what will happen with any such systems.

OpenAI: GPT-6 Astra

openai/gpt-6-astra

GPT-6 Astra is OpenAI's flagship model for demanding end-to-end work. It is suited for advanced analysis, software engineering, deep research, scientific work, and document creation, with particular strengths in long-horizon agentic tasks that involve computer and browser use.

Modalities

In / Out Price

$10 / $50per 1M

Context

1M

Released

Sep 4, 2026

ProvidersPricingPerformanceUptimeBenchmarksAppsActivityFAQExplore

Providers

Different companies host the same model. OpenRouter routes your request to one of them based on the routing mode you pick — Balanced (price + speed), Nitro (fastest), or Exacto (highest tool-calling accuracy).

Pricing

The average price customers actually pay for this model, next to the prices providers post. Caching and discounts mean the price actually paid is often well below the listed one.

Performance

Throughput is how fast the model writes (tokens per second — higher is better). Latency is total round-trip time (lower is better). TTFT is time-to-first-token — how long before you see anything appear (lower is better).

Uptime

Uptime is the percentage of the past 3 days that at least one provider was responding to requests. Availability is the percentage of time that inference was successfully served. OpenRouter continuously monitors and uses the next-best provider when one returns an error.

Benchmarks

Scores on standardized evaluations. Higher percentages are better — and rank percentile shows where this model lands among all models on OpenRouter.

Apps

Public apps that send the most traffic to this model. Good signal for what real production workloads look like — and a hint at which use cases this model is best suited for.

Activity

Token volume and request traffic to this model over time.

Quick Start

Drop-in code to call this model. OpenRouter's API is OpenAI-compatible — most SDKs work by just swapping the base URL. The only thing that changes between models is the model slug below.

Standard

Latency / throughputP50

ProviderInput /MOutput /MCache read /MLatencyThroughputUptime

OpenAI Flex

$5.00$25.00$0.503.77s55 tps

99.99%

Azure

$10.00$50.00$1.003.19s39 tps

99.15%

OpenAI

$10.00$50.00$1.004.07s40 tps

98.76%

Azure (US)

$11.00$55.00$1.104.48s31 tps

99.15%

OpenAI Fast

$20.00$100.00$2.002.57s51 tps

100.00%

Throughput

55tok/s

P50, best across providers

Latency

2.56s

P50, best provider

All locations

Latency / throughputP503 days

Uptime (3d)

100.00%

Availability (3d)

98.36%

Availability over the last 3 days

Last 72 hours

Availability 98.36%

3 Days Ago2 Days AgoYesterdayNow

Availability over the last 24 hours

OpenRouter Availability

98.41%

Without Routing

95.57%

When an error occurs in an upstream provider, we can recover by routing to another healthy provider, if your request filters allow it. You can access per-provider uptime data programmatically through the Endpoints API. Learn more about our load balancing and customization options.

Frequently asked questions

What is GPT-6 Astra?

GPT-6 Astra is OpenAI's flagship model for demanding end-to-end work. It is suited for advanced analysis, software engineering, deep research, scientific work, and document creation, with particular strengths in long-horizon agentic tasks that involve computer and browser use.

How much does GPT-6 Astra cost?

GPT-6 Astra costs $10.00/M input tokens and $50.00/M output tokens, with separate rates for Cache Read at $1.00/M tokens, Cache Write at $12.50/M tokens and Web Search at $10.00/1K calls.

What is the context length of GPT-6 Astra?

GPT-6 Astra has a 1,050,000 token context window. It supports up to 128,000 completion tokens.

Does GPT-6 Astra support tool calling and structured outputs?

Yes. GPT-6 Astra accepts tools and tool_choice for function calling. It also supports structured outputs via a JSON schema in response_format.

What inputs and outputs does GPT-6 Astra support?

GPT-6 Astra accepts files such as PDFs, images and text as input and returns text.

Which providers serve GPT-6 Astra?

GPT-6 Astra is served by 2 providers on OpenRouter: OpenAI and Azure (US). Requests are routed to the best available provider, with automatic failover to the others, and you can pin or exclude providers with provider routing.

When was GPT-6 Astra released?

GPT-6 Astra was released on September 4, 2026.

Over 23 days (August 9 to 31, 2026), we tracked more than 2 million product listings across more than 100,000 SERPs and AI Mode responses. We ran the same shopping queries through both Google AI Mode and traditional search on the same day at the same moment. When the exact same product showed up on both, the price in AI Mode was 21.6% higher on average.

When the same product appears on both sides, how do the prices compare? And how does the overall mix of recommended products differ between the two? That's what this study set out to answer.

Key findings at a glance:

• For matched products ranking in both AI Mode and traditional search, AI Mode is 21.6% more expensive.
• Looking at all products on each side (not just the matches), AI Mode listings sit 49% higher than traditional search listings.
• Only 1.28% of products ranking in traditional search also appear in AI Mode for the same search on the same day.
• Matched products show a price discrepancy 38.1% of the time; when they do, AI Mode is more expensive 68.4% of the time (about two-thirds).
• The main seller differs on 49.6% of matched products.

Finding 1: the same products cost more in AI Mode

This is the most direct comparison in the study. Same product, same search, so the only thing changing is which search type you are on. We matched products across AI Mode and traditional search, then compared the lead price on each side. Across those matched pairs, AI Mode was 21.6% more expensive.

This is a fascinating study that reveals more about Google's Shopping Graph and the inconsistencies between classic search and AI Mode for free listing placements. While the higher price might be displayed within the grid result in AI Mode (making the top-level comparison less accurate), what we tend to see is that the retailer with the lowest price gets the click in the end.

This research is useful from a consumer perspective, as it is helpful to understand that the products being recommended in AI Mode might not be giving 'price' as much weighting as we would have expected.

The screenshots below are real examples from our dataset. Each pair is from the same search: traditional search on the left, AI Mode on the right.

Example: #1 position, AI Mode 26% more expensive

Traditional search

AI Mode

Example: different seller, 19% higher in AI Mode

Traditional search

AI Mode

Same product, same query, and the price on the right is consistently higher.

AI search was supposed to eliminate the friction of comparing prices across five different tabs, but if it only serves pricier inventory by default, it hasn't saved us any work. We're trading the visible effort of opening multiple windows for the invisible penalty of paying more without ever seeing the cheaper option that was one tab over.

When algorithms favor the more expensive item two-thirds of the time and swap out the seller entirely, it changes how discovery works. Open market comparison is replaced by a curated path to higher-priced stock. If these platforms are built for users, it's worth asking: who actually benefits from this?

Finding 2: AI Mode tends to surface higher-priced products

Matched products give the cleanest comparison, but they're only part of the picture. To see the bigger pattern, we also compared every priced listing on each side, including products that appear on only one of them.

On this broader basis, the typical product in AI Mode is priced well above the typical product in traditional search: a median of $149 in AI Mode versus $100 in traditional search, about 49% higher.

The chart below shows the full spread of prices on each side.

The AI Mode side looks smaller for a simple reason: AI Mode shows far fewer products to begin with, so it makes up a much smaller share of all the listings we tracked. This is in line with our previous study. In the current data set, AI Mode makes up just 12.3% of all the products shown, an average of 3.9 products versus 27.8 in traditional search.

Example: pre-owned outlier in traditional search, new price in AI Mode

Traditional search

AI Mode showing a higher new-condition price

AI Mode

Example: #1 position, slightly higher in AI Mode, different seller and title

SERP #1 with slightly lower price and different seller

Traditional search

AI Mode #1 with slightly higher price

AI Mode

Finding 3: very little product overlap between AI Mode and traditional search

Even when both sides respond to the same search, they rarely show the same products on the same day. Across our data, only 1.28% of products ranking in traditional search also appeared in AI Mode. Our July study found a similar pattern at a broader level: AI Mode ranked just ~5% of the products that rank in traditional search overall.

The overlapping product number is an interesting finding: when both sides respond to the same query, they rarely land on the same products. And the ones AI Mode does pick are going against the grain with how Google usually rewards the cheapest listing.

Seeing that prices in AI Mode are +21.6% more expensive is a stark contrast to the way we've seen Google rank products within product listings. It's often the cheapest product getting the most attention (and the best visual treatment). Not to mention, Google has rolled out features specifically for price-conscious shoppers.

Those same pricing treatments are effectively forgotten in the AI Mode examples.

Not only is AI Mode showing fewer products, they're showing more expensive ones. I think this is a small win for merchants who don't always want to compete solely on price.

One thing not explicitly stated in the study but something I observed from the screenshots: AI Mode seems more likely to link to the brand's website itself over the marketplace, as we also tend to see. If we're seeing that it's the merchant's website taking priority over third-party marketplaces (for applicable products), this is huge.

This is another reason why enriching your product feed data with things like Product Highlights and Product Details helps AI better serve your product.

Finding 4: when prices disagree, AI Mode is more expensive two-thirds of the time

When the same product appears on both sides, the two prices actually disagree 38.1% of the time. When they do, AI Mode is the pricier one in about two-thirds of cases (68.4%).

When AI Mode is the more expensive side, the median price difference is 22.2%. The average is 88.5%, but that figure is heavily influenced by extreme outliers (for example, a used item in traditional search matched against a new one in AI Mode).

Example: deal price in traditional search, 12.5% higher in AI Mode

SERP with a deal price significantly lower than AI Mode

Traditional search

AI Mode about 12.5% more expensive

AI Mode

When prices do disagree, AI Mode is more often the expensive side, and often by a significant margin.

As a consumer, this hits hard given the pressures around cost of living and economic instability. It also challenges the general consensus that AI provides a better, more customer-focused shopping experience, particularly when you look at AI's ability to lower cognitive load compared with a more traditional search experience, with the price discrepancy in mind.

Depending on the market, between 30% and 75% of consumers cite price as the most important factor in a purchase decision, so this discrepancy could directly impact revenue even if you are performing in both experiences.

As a brand, it highlights the need for increasing visibility on what AI is showing users. 'Fact-checking' AI in shopping experiences just got a whole lot more important. I'll be considering exactly how 'aligned' SEO and GEO are, focusing more on how I might track shopping feed visibility and aiming to align every data-source I have to 'one price'.

Finding 5: when AI Mode is cheaper, the gap is smaller

On the remaining cases where AI Mode is cheaper, the median price difference is 7.8% and the average is 11.9%, a smaller gap than when AI Mode is the expensive side.

Example: AI Mode slightly cheaper via different seller and image

SERP slightly more expensive with 360-degree product image

Traditional search

AI Mode slightly cheaper with different seller and image

AI Mode

Example: AI Mode slightly cheaper (outlier), traditional search 1% more expensive

SERP about 1% more expensive than AI Mode

Traditional search

AI Mode slightly cheaper via different seller

AI Mode

Finding 6: different sellers nearly half the time

When the same product ranks on both AI Mode and traditional search, the main seller is different 49.6% of the time. Price and seller changes often travel together.

A different price is one thing. A different seller on the same product is another, and our data shows that happens nearly half the time.

More product examples

Not every matched product shows a price gap. These additional pairs illustrate same-price listings, title rewrites, and ranking differences on otherwise identical offers.

Example: same price and seller, different title

Traditional SERP: same price and seller, different product title

Traditional search

AI Mode: same price and seller, different product title

AI Mode

Example: same offer ranked #8 in traditional search vs #1 in AI Mode

SERP ranking #8 with same seller and price as AI Mode #1

Traditional search

AI Mode ranking #1 with same seller and price

AI Mode

These examples show that matched products don't always carry a price gap. In fact the prices agree about 68% of the time, even when the lead seller is different.

Why this matters

Shoppers tend to assume AI Mode is working on their behalf, surfacing the best option the way regular search has done for years. The lead price isn't the only one available: click a product in either AI Mode or traditional search, and a knowledge panel opens in the sidebar listing other sellers and their prices. But that takes a deliberate click, and most people won't make it. When the main listing is presented as the recommended choice, it's reasonable to assume it already carries the best price, so there's little reason to go hunting for a cheaper seller. The number shoppers see first is the number most will act on, and in AI Mode that number tends to be higher.

This is a snapshot of a surface Google is still actively evolving, which is why I'd pay attention to the ongoing trackers as much as the data in this study. Google has a clear incentive to get people from a question to a purchase faster, and four products in an answer does that better than twenty.

You can already see it in the format: more text and education sitting alongside the product recommendations, so the research that used to happen across five tabs now happens in the answer. I'd expect buying cycles to shorten because of it. Solid product data and covering your customer journey is now an absolute must.

As Google moves more shopping journeys into AI Mode, often carrying the same query straight over so the shopper doesn't realize the search type changed, that blind spot matters. Brands need to know what Google recommends there, and at what price, not just what ranks in the familiar carousel.

It's worth looking at how directly Google routes shoppers into AI Mode, because in most cases the switch happens without any deliberate choice. The same query carries straight over, so from the shopper's point of view nothing appears to change. Here's where those entry points show up.

Google now shows a prominent AI Mode directly on the standard search box, which leads to AI Mode while keeping the same query in place.

Google search UI promoting AI Mode while keeping the same query

Desktop browsers using Chrome have the AI Mode button straight in the address bar.

Google search UI showing AI Mode in the Chrome address bar

Search results come with an AI mode tab, which leads straight into AI Mode while using the same query.

Google search UI siphoning users into AI Mode

Google has spent the last year pulling AI Mode closer and closer to the standard search experience, and they've said they intend to keep going. As that happens, the price a shopper sees first matters more, because most people don't go hunting past it. The lead listing acts as an anchor: click through on either surface and the knowledge panel still lists other sellers, sometimes cheaper ones, but reaching it takes a click that most shoppers don't make.

What the data suggests is that the cheapest price is less of a factor in AI Mode. And if the model isn't gating visibility on lowest-price, that changes who gets to compete. Brands that cannot win the race to the bottom may now have a better shot: better feeds, richer product data, reviews and alignment with shopping conversations can make an AI confident enough to recommend them.

Our methodology

Over 23 days, we tracked more than 2 million product listings across more than 100,000 SERPs and AI Mode responses, running the same query on both sides on the same calendar day. We tracked product-centric shopping queries in the US and UK from August 9 to August 31, 2026. On the SERP side we limited analysis to popular_products carousel listings; on the AI Mode side we used all tracked product cards. Products were matched across sides using Google's stable product identifier when present, for the same query on the same calendar day.

Headline prices in Findings 1, 4 and 5 compare matched products only: the same product, for the same query, on the same calendar day. For each pair we take the lead offer on each side (lowest listing position), then measure how much higher or lower the AI Mode price was relative to the traditional search price: (AI Mode price − SERP price) / SERP price. Finding 2 uses a separate, broader comparison that includes every priced listing on each side, not just matches, and reports the difference between the two medians. US prices are in USD and UK prices are in GBP; we do not convert currencies.

For the remaining matched-product stats (how often prices disagree, which side is higher, seller mismatch), we use the same lead-offer pairs as the headline. For overlap, we calculated a match rate for each day (matched products divided by all traditional-search listings with a product identifier), then averaged those daily rates. While this study uses a completely new dataset, it is a natural follow-up to our July 2026 study, which found that AI Mode returns about 95% fewer product listings than traditional search on the same queries.

About this study

This study was produced by Productrise, a platform for tracking organic product visibility in Google. All figures were computed directly from our tracking database over the study window. You are welcome to reuse, reference, or republish the charts and findings, as long as you attribute Productrise and link back to this page. Questions or data requests are welcome at hello@productrise.app.

Welcome to IBM Bob:

Your AI-Powered Development Partner

Hi, I'm Bob! I'm here to work right alongside you in your codebase, and help you build quality software faster.

Get free trial

Download

What I can build with you

Build with agents

I can spawn focused agents and subagents that contribute to your code base. Each agent uses its own context, tools, and skills, to run work in parallel to handle long-running tasks in the background, and return only what matters. Faster answers. Clean context. Clearer results across even the largest projects.

Develop in your favorite human language

With Literate Coding, forget context-switching between chat windows and your editor. Explain what you want in natural language and I will generate the implementation in context.

Bring agents to your command line

I'm not confined to your IDE. With Bob Shell, I can help you work interactively, script repetitive tasks, and embed into your CI/CD pipeline across every stage of development.

Understand every agent's impact

Track Bob's contributions to your software delivery lifecycle across the entire enterprise. Drive agentic adoption, prove real business value, and optimize the costs through comprehensive analytics and insights with Bobalytics.

Premium packages that move your stack forward

I accelerate transformation across your applications. With premium packages, I bring purpose-built modes, skills, and workflows for enterprise modernization, from upgrading Java applications to the latest versions, to mainframe and IBM i development.

Access IBM's enterprise ecosystem with ease

Connect to Red Hat, Instana, and more directly from your IDE. I eliminate context switching and bring enterprise-grade architecture, security, and monitoring right where you code.

What developers say

Bob demonstrated a level of intelligence and contextual understanding that goes beyond anything I've seen in other tools.

Luis Fabricio de Llamas
Sr. Java Developer & Developer Advocate, Act Digital

M.R. Williams is advancing its IBM i modernization strategy with new mobile solutions and accounting system improvements, while leveraging IBM Bob to quickly interpret older RPG code, automate documentation, and streamline development workflows.

Jasmine Kaczmarek
VP of Technology, M.R. Willians

The tool works very well and captures the modernization intent. Bob is the first tool of its kind to treat Java as a first-class citizen

Artur Skowronski
Head of Java & Kotlin Engineering, VirtusLab

IBM Bob had a solid understanding of IoT development, including peripheral chips and devices, and was able to generate everything seamlessly from physical connections through to code. Bob is a highly reliable partner.

Shintaro Shibuya
CEO, TechMind Inc.

IBM Bob isn't just another autocomplete tool. It is an AI-first development partner designed to transform the entire software lifecycle. Think of it as moving from 'help me code' to 'help me modernize, secure, and scale.'

Christina Adames
AI Strategist, CDW

We leveraged BOB to modernise Java codebase from Java 11 to Java 25 and achieved an estimated ~90% faster delivery — 3 days vs. ~30+ days via a typical approach. The outcome was genuinely impressive and has opened multiple use cases for Blue Pearl to incorporate IBM BOB across our internal platforms as well as client engagements.

Sai Govender
CEO, Blue Pearl

Early results are very promising: in under 15 minutes, I had a small FPS-style prototype up and running while walking my son through what Bob can do. That combination of speed and explainability is exactly what I'm looking for in an AI coding companion.

Reshad Moussa
Director of Product Development, Supplier Shield

We use Bob for IBM i development, and one of its biggest strengths is its strong support for RPG and COBOL. Even with minimal instructions, it consistently gives spot-on answers, almost as if it can read between the lines.

Takeshi Sugata
Director, MONO-X Inc.

Project Bob isn't just another AI assistant. It's an agentic AI development partner built for large organizations tackling complex challenges — like modernizing legacy systems, ensuring compliance (HIPAA, FedRAMP), or scaling secure software delivery.

Hans Boef
Manager Technical Consultants and Support, Novadoc

Project Bob sounds so wonderfully innocent but it is incredibly powerful. 3 prompts. That's all it took to build a production-ready MCP server. Project Bob blew my expectations out of the water. Bob delivers the kind of work you'd expect from an experienced developer who actually thinks about the full picture.

Wesley Wienen
Technical Presale Engineer, Appsys ICT Group

Bob has built-in guardrails. It operates in different modes, allowing you to approve its suggestions before any changes are made to your source code. If you ask it about a non-existent RPG op-code, it won't "hallucinate" an answer; it will simply state that it doesn't understand. This controlled, predictable behavior is crucial for enterprise development.

Steve Cast
Practice Director, Fresche Solutions

We built an application that processes video frames in parallel using OCR. By working closely with Bob, we were able to move smoothly from design to environment setup and deployment, resulting in significant improvements in both implementation accuracy and development speed.

Shigehiro Mouri
General Manager, System Research

When IBM Bob is given an RPG program, Bob is able to help us modernize it into our new java architecture quickly. IBM Bob reads and understands RPG code very well and was great for validating logic rewrites that have been done on multiple programs. It also adapted to our Java code architecture well, using predefined internal libraries and database connections.

Joe Donofrio
Director of IT, Wolff Bros

We load all the course materials into Project Bob and work together to identify where students are likely to get stuck. It supports them throughout the process, from understanding the context to polishing their writing, which reduces back and forth and saves a lot of time.

Shigeru Ueda
Manager, Chukyo TV Broadcasting Company

The world’s top Go player notches a 2-1 comeback win against the most powerful Go engine, raising hope for human intellect in the AI era

Shin Jin-seo, the world's top-ranked Go player, reviews the game board following his victory over AI engine KataGo in the final game of a three-match series at The Korea Economic Daily headquarters in Seoul on July 21, 2026 (Photo by Hyuk Choi)

Artificial intelligence

Shin Jin-seo, the world's top-ranked Go player, on Tuesday completed a dramatic comeback against the world’s premier artificial intelligence Go engine, KataGo, claiming a historic human victory over AI.

Shin, who holds the game's highest achievable rank of nine-dan, dealt KataGo a decisive 11.5-point defeat playing black in 221 moves in the series finale, which took three hours and five minutes.

The 26-year-old South Korean grandmaster became the first human to win an official series against a state-of-the-art Go engine under a two-stone handicap, a margin considered the absolute boundary for human competition against modern AI.

“I believe this series holds immense significance because it clearly demonstrated that humans can still hold their own against AI,” Shin told reporters after the match.

“Early on, I simply copied AI moves, which led to heavy fighting and frequent, easy losses. This series taught me that rather than trying to imitate AI, it is far more important to build the board according to my own style.”

In the three-game series, Shin suffered a resounding defeat to KataGo in the opening match on July 17, but rebounded to beat the Go engine in the second game on Sunday.

Shin Jin-seo poses for a photo after defeating AI engine KataGo in the final game of a three-match series at The Korea Economic Daily headquarters in Seoul on July 21, 2026 (Photo by Hyuk Choi)

DECISIVE ATTACK ON MOVE 80 AFTER FOCUSING ON DEFENSE

Unlike earlier matches filled with sharp tactical clashes, the third game developed into a territory-focused contest with little fighting through the middle stages.

Shin focused on defense and territory preservation rather than pursuing risky counterattacks, maintaining an initial 18.5-point advantage.

But he launched a measured attack against KataGo on move 80, building a massive framework that spanned from the upper board to the center.

By converting this framework into solid territory, Shin maintained a 99% win probability from mid-game through to the final move.

“I noticed KataGo tends to match moves if I open on the opposite komoku, but I didn't want to win that way,” Shin said. Komoku is the Japanese term for the three-to-four point on a Go board.

“I knew even a one-space difference could be significant, so I started on the opposite side from KataGo. Even so, I was satisfied with how the opening developed.”

Shin won 250 million won ($170,000) in match fees and prize money, along with a Genesis G90, Hyundai Motor Co.’s luxury sedan, as a performance award.

UNEXPECTED VICTORY

Heading into the event, few had expected Shin to beat KataGo in the landmark series, especially given that the AI engine is more sophisticated than previous models that had thwarted other Go grandmasters in the past.

The Go match between AlphaGo and South Korean legend Lee Sedol in March 2016 (Courtesy of Yonhap)

In 2016, Google DeepMind's AlphaGo defeated Korean Go legend Lee Sedol 4-1.

Reflecting on that landmark match, Shin noted that taking even a single game against AI at the time felt like a monumental feat.

“My victory may fall short when compared to the single win achieved by master Lee Sedol,” he said.

No human Go player had defeated AI engines in an official series before Shin.

AlphaGo Master, an upgraded version of AlphaGo, beat then-world No. 1 Go player Ke Jie 3-0 in a legendary match at the Future of Go Summit in Wuzhen, China, in May 2017. That marked a definitive moment in which artificial intelligence surpassed humanity at the ancient board game, with the closest game ending in a razor-thin 0.5-point margin.

Ke was unable to contain his frustration and even shed tears during the final game when it became clear he had no chance of winning.

TAKING ON DISADVANTAGEOUS CONDITIONS

Shin’s victory is significant because, even with a two-stone handicap, holding a lead against a near-flawless AI requires an elite player to suppress tactical instincts and defend with extreme patience and restraint, Go experts said.

Given the widely acknowledged skill gap between modern AI and human professionals, the series was played under handicap conditions.

Handicaps in Go are adjustments made to level the playing field when two players have a difference in skill, offsetting these differences so players of different ranks can have an exciting game. The weaker player takes the black stones and places from two to nine preset stones on the board before the game begins.

Shin, who placed two stones on the board before each of the three games, hinted at wanting to further test his limits.

“At future events, I want to take on new challenges, such as starting under more disadvantageous conditions against AI.”

Shin speaks to the press after defeating AI engine KataGo in the final game of a three-match series at The Korea Economic Daily headquarters in Seoul on July 21, 2026 (Photo by Hyuk Choi)

HOPE FOR HUMANITY

Shin’s victory offered a rare reminder that human players can still push the boundaries of Go in the AI era.

Hong Beom-jun, CEO of Truebook Sinsago, which co-sponsored the series with The Korea Economic Daily, said the historic victory served as a key turning point in restoring human confidence, which had been damaged by AlphaGo’s victory in 2016.

“The significance of this match lies not in the win or loss between humans and artificial intelligence, but in the process of how humans continually adapt their approach to achieve their goals,” Hong said.

Referencing Shin’s opening loss, Hong emphasized the resilience needed to overcome superior computing power.

“There was a problem with the method in the first match, but the goal itself was not wrong. Shin shifted his strategy in the second and third matches toward a defensive, disciplined style, and ultimately prevailed.”

“That is the true lesson of this series.”

Hong announced plans to host the same event again next year, adding that organizers are working to level the playing field between human players and machine intelligence.

React Now Rusted All The Way Out

Following the oxc team’s release of official support for the Rust React Compiler on August 4, 2026, we switched our 1,036-file React Router codebase (Outlyne, a website builder) over to it and saw a ~17.6× speedup on the compiler portion of our build.

The v6.1.0 release of @vitejs/plugin-react brought “experimental native React Compiler support”, which you can opt in to by passing { compiler: true } to the plugin in your Vite config. And for those unable to use the Vite React plugin (e.g. if, like us, you’re using React Router in framework mode), @acusti/vite-plugin-react-compiler is a minimal Vite plugin to React-compile your codebase regardless of the rest of your build pipeline.

Faster Builds = Happier Devs + Cheaper CI

The headline feature of this change is the speedup. Per Boshen, the oxc project lead:

It is more than 10 times faster than Babel in our preliminary benchmark.

We saw more than a 17× speedup, with 1,036 files going from 14.3s when built with Babel to 0.81s natively (single-threaded). This is huge for us because, with the speed of change brought about by agent-assisted software development, CI usage and GitHub Actions minutes have become a real cost center, and waiting on CI is a bummer and puts further pressure on our already overly fragmented task-management brains.

Note that those speedups apply only to the compiler part of the build process. You likely have a lot of other stuff going on during the build, so the overall build time improvement won’t be nearly as dramatic. In our case, the build got around 2.4× faster (22.1s → 9.3s).

What about React Compiler’s limitations?

Despite speed being the headliner, I’m more excited about the benefits of being on the latest and greatest version of the React Compiler, which has already fixed some substantial limitations in JavaScript support that were still present in v1.0 of the Babel-based React Compiler. That includes support for any kind of conditional logic in try/catch blocks, which was a blocker for many with the initial stable 1.0 release of the compiler. Another nice fix that landed just last week at the time of writing is support for reassigning a destructured component prop that then gets used in a nested closure, e.g.:

export default function Foo({ value }: { value: null | string }) {
  value = value ?? "this is a fallback";
  return <button onClick={() => console.log(value)}>{value}</button>;
}

Skipped before, fully supported now. A third common pattern that caused bailouts in the Babel compiler that’s now supported is computed object property keys, e.g.:

import { clsx } from "clsx";

export default function Header({ itemCount }: { itemCount: number }) {
  return (
    <header className={clsx({ [`items-${itemCount}`]: itemCount > 0 })}>
      {/* ... */}
    </header>
  );
}

Those fixes mean that the new version expands compiler compatibility in our app by an additional seven functions: five thanks to the try/catch improvement, two thanks to computed object property keys. To be clear, there are still limitations to what it supports. The two patterns that I have come across that will still cause the compiler to skip a component/hook are a throw from inside a try block and logical assignment operators (??=, &&=, ||=). But being on the Rust compiler means you will get those fixes when they land. No such luck if you’re stuck on the dead-end Babel-based compiler.

Toolchain Consistency Means No Coverage Gaps

The final reason I’m excited about switching my build over is that my full toolchain is now using the same version of React Compiler with equivalent feature support. After adopting Oxlint’s React Compiler support while still on an earlier version of React Compiler for my build, I filed an erroneous issue in oxc based on the destructured component prop bailout I described earlier, because the component wasn’t optimized during build but also didn’t trigger a lint error, so I thought there was a lint disconnect with the compiler output. Turns out the issue was that Oxlint was using oxc-transform-react v0.145.0, which supports that pattern, whereas I was testing with v0.144.0 of the same package.

Now, linter and build use the exact same React Compiler, with the same improvements and limitations, so we don’t have to worry about uncompiled components slipping into our production build.

How to Use It

Using @vitejs/plugin-react

As long as you’re on Vite v8+, switching an existing React Vite build to native React Compiler really just means simplifying it. The current Babel-based react.dev instructions specify to run:

npm install -D @rolldown/plugin-babel

With the following Vite config:

// vite.config.js
import { defineConfig } from "vite";
import react, { reactCompilerPreset } from "@vitejs/plugin-react";
import babel from "@rolldown/plugin-babel";

export default defineConfig({
  plugins: [react(), babel({ presets: [reactCompilerPreset()] })],
});

Going native means shedding some config dead weight. You run:

npm install -D oxc-transform-react

And simplify your Vite config:

// vite.config.js
import { defineConfig } from "vite";
import react from "@vitejs/plugin-react";

export default defineConfig({
  plugins: [react({ compiler: true })],
});

This also means you can remove @rolldown/plugin-babel from your package.json dev dependencies.

Not Using @vitejs/plugin-react (e.g. React Router Framework Mode)

For codebases that are on React Router in framework mode, the switch is a little different. React Router has its own Vite plugin that should be run in place of the Vite React plugin, so whereas you previously needed to run:

npm install -D vite-plugin-babel babel-plugin-react-compiler @babel/preset-typescript

With the following Vite config:

// vite.config.js
import { defineConfig } from "vite";
import babel from "vite-plugin-babel";
import { reactRouter } from "@react-router/dev/vite";

const ReactCompilerConfig = {
  /* optional config if you have it */
};

export default defineConfig({
  plugins: [
    reactRouter(),
    babel({
      babelConfig: {
        presets: ["@babel/preset-typescript"], // if you use TypeScript
        plugins: [["babel-plugin-react-compiler", ReactCompilerConfig]],
      },
      exclude: /node_modules/,
      include: /\.[jt]sx?$/,
    }),
  ],
});

You can now drop vite-plugin-babel, babel-plugin-react-compiler, and @babel/preset-typescript entirely and instead just install:

npm install -D @acusti/vite-plugin-react-compiler

And simplify your config to:

// vite.config.js
import { defineConfig } from "vite";
import reactCompiler from "@acusti/vite-plugin-react-compiler";
import { reactRouter } from "@react-router/dev/vite";

export default defineConfig({
  plugins: [reactRouter(), reactCompiler()],
  // or, if you need to pass custom compiler config:
  // reactCompiler({ compiler: { /* your existing ReactCompilerConfig */ } })
});

Simpler, faster, and more capable. Cheers to that. I think I know just the right drink.

I love research and development, you may have heard of me because of PJON (Padded Jittering Operative Network). It is a network protocol I started developing in 2010, which was recently implemented in silicon by the ETH Zurich university thanks to the research of Pius Sieber.

I had a chance to focus for 2 months on my personal projects since early July, during the strange times of AI price hikes and the end of subsidized tokenmaxing. I was curious to see if I could develop from scratch a terminal assistant capable of handling simple natural language requests. I have a bad memory and got used to ask to copilot "activate the virtual environment" or similar trivial operations spending a non negligible sum every month. I started thinking, maybe I can do something to make my workflow more efficient? Do I really need trillions of parameters to accomplish those tasks?

Transformers at home

I started an open-ended research on the feasibility of implementing a generative model at home and training it from scratch on the computer I used to play Kerbal Space Program in the early 2010s "upgraded" with 16GB of RAM, NVIDIA GTX 1050 Ti (4GB VRAM) and a i7-4790K (4.0GHz 8 cores) CPU. In my experiments I tend to look for minimalism, so I imposed myself a constrained environment to be forced to work towards an elegant and efficient solution.

I first developed a framework to train and evaluate transformers, which I implemented from scratch in Python. I have started with something very similar to NanoGPT with 100-200M parameters, then I added flash attention, and all the expected optimizations, I even tried novel architectures like Mamba. The results were generally unsatisfactory, creepy if not outright scary, like the following:

Enter your prompt (or leave blank for empty start):

What is an alien?

Generating...

Using tokenizer: /ollm/checkpoints/gpt/tinyostrich/tokenizer.model

=== Generated Text ===

He's not a member of the world. He can't believe anything anymore.
All of those animals are looking like excrements, but every mouth is not a bad one.
They look alike, all of which are really terrible.
They get their own life, and each is a sign that they're not.
They're all right, they say.
They're just some different things they can make.
They've never seen them.
They were better not. Some of them've got their rights.
Some of them have to go.
But we're not looking for the future on how many.
The last two of them are all in the universe.

(the word excrements was used instead of an expletive composed of 4 letters that I am not willing to publish in here)

All my tests produced models that were prone to enter in loops repeating the same sentence, and even if trained on QA they were rarely able to consistently answer questions, specially if technical. I trained models on a collection of royalty free books from the Project Gutemberg, a lot of open-source software, and various datasets available on Huggingface.

I quickly understood that this approach was not feasible; a proper run would have required at least a month of training non-stop. I was amazed by how my models looked alive and magical, but I was also ashamed because they were incredibly wasteful and effectively useless.

Local models

I pivoted to ollama and open-weight models and developed howto, yet another terminal harness that uses a pre-prompt to force the model to answer only with terminal commands. Results were generally unsatisfactory because of the time required to get a response. Models like ornith:9b, mistral:7b or cogito:14b can get the job done sometimes, but they are not fast and reliable enough for general use, specially if you have only 4GB of VRAM.

Going deterministic

Then I remembered about the blockchain craze, when everyone wanted to fit a blockchain somewhere and sell it as the next big thing. I didn't want to waste my time and money like all those people did in the previous hype cycle, so I started building a terminal assistant from scratch with a new set of constraints:

1. No embeddings
2. No machine-learning
3. No LLMs

Dataset format

The first things I needed was a set of conventions to rely on, so I drafted the NDF 0.0 (NPC-Forge Dataset Format which specifies the dataset format of NPC-Forge. The following object contains category, input sentences, textual response, thinking traces, permission gating and tool calls to be executed in a format compatible with VS code.

{
    "category": "linux_files",
    "input": [
        "list files",
        "list files and directories"
    ],
    "tools": [
        {
            "name": "run_in_terminal",
            "arguments": {
                "command": "ls -lah",
                "explanation": "Lists the files in the current directory.",
                "goal": "Display current directory contents",
                "mode": "sync"
            }
        }
    ],
    "message": "Done",
    "thinking": [
      "That is quite simple!",
      "This is boring..."
    ],
    "permission": "yolo"
}

I am really in love with this, it is a self-contained atom of knowledge that can be easily edited and shared. It is very simple to expand the capabilities of conversational agents if you adhere to this convention; let's say I want my terminal assistant to learn about docker commands, I can just write down a list of objects in dataset_docker.json, drop the file in the dataset directory, and the NPC will instantly learn them as Neo learnt Jujitsu in The Matrix.

The next problem to solve was, how to handle questions like "create file test.txt"? I needed to parse the "variable" in there and understand the true meaning of the request, so I came up with this:

{
    "intent": "file_creation",
    "category": "linux_files",
    "type": "template",
    "structure": [
        [
            {
                "tag": "<||vocab_create||>",
                "type": "vocab",
                "required": true
            },
            {
                "tag": "<||vocab_file||>",
                "type": "vocab",
                "required": false
            },
            {
                "tag": "<||file||>",
                "type": "filename",
                "required": true
            }
        ]
    ],
    "message": "<||completion||>",
    "tools": [
        {
            "name": "run_in_terminal",
            "arguments": {
                "command": "echo '' > '<||file||>' && termy_set_context 'active_file' '<||file||>'",
                "explanation": "Writes <||string||> in file <||file||>.",
                "goal": "Directory Allocation",
                "mode": "sync"
            }
        }
    ],
    "permission": "ask",
    "thinking": [
        "Ok, I am asked to create the file <||file||>."
    ]
},

Each tag like <||vocab_create||> represents a concept, in this case the action of creation, which is represented by multiple sinonyms:

{
  "<||vocab_create||>": [
    "create",
    "make",
    "generate",
    "craft",
    "forge"
  ]
}

One or more tags can be expected at the same position and each tag can be required or optional. The "variables" or named entities are extracted according to their type and a related regular expression:

{
  "<||filename||>": "[\\w\\-]+\\.[a-zA-Z0-9]{2,4}",
}

I must thank my great friend Kevin to help me thinking this out.

Meditations on safety

Looking at the permission key I concluded that, enforcing the use of "permission": "ask" for all potentially destructive commands, the tool became inherently safe to use; obviously potential for human error remained, such as a bug in the implementation or in the dataset, but risks were strongly mitigated.

The implementation

I wrote FlintParser and FlintNPC classes to make use of the data format described above, implement a NLU (Natural Language Understanding) pipeline, and all the required features for the terminal assistant to work in around 1000 lines of code. I wrote those classes in identical, cross-compliant implementations for both Python, for local OS environments, and JavaScript, running client-side inside any browser tab or Node.js instance.

The most difficult part was to determine what to do and in which order. I have worked a lot on a compiler for my own programming language BIPLAN and while developing that I had the honour to learn that the first thing you need to do when translating code is to remove noise and then work your way out trying the least expensive paths first.

So that's the pipeline I implemented:

1. Strip expletives, interjections, encouraging, discouraging and thanking words (remove noise)
2. Sentiment analysis
3. Exact Match (very fast)
4. Template Match (slower)
5. Probabilistic Match (even slower)

Step 5 relies on:

1. IDF (Inverse Document Frequency) to identify rare words.
2. BOW (Bag Of Words) to accommodate word inversions.
3. IDF weighted Levenshtein to safely handle typos.

For the first time after almost 2 months throwing spaghetti at the wall and hope they stuck, I felt again the joy of working on something comprehensible and predictable. I finally had a reliable terminal assistant working on my computer!

I decided to call it TERMy:

How this compares to established NLU frameworks? Rasa and NLP.js are heavy and rely on machine learning classifiers and training pipelines, ChatScript is massive with a notoriously steep learning curve. NPC-Forge strips all that away, requiring zero training, specifying a powerful and flexible data format, and featuring a surprisingly capable parser small enough to run on a micro-controller.

Let's connect it to Copilot

I have developed TERMy and connected it to Copilot to handle a subset of the prompts I was before sending to Claude! It is not an LLM but it gets the job done and it is instantaneous! I suspect this is the first time most of us see a deterministic agent using a harness, although, I believe, this will be the prevalent topic in the near future:

It is ironic to think that Copilot's recent price hikes are what finally pushed me to dedicate time to this software. Maybe it's just the lifecycle of corporate SaaS? In any case, I believe that harnesses like Copilot and Pi should rely on deterministic NPCs like TERMy and route to a heavy LLM only as a last resort. Continuing to waste compute and electricity on trivial tasks is expensive and irresponsible.

NPC-Forge

NPC-Forge is a framework, a server and a CLI that provides the following functionalities:

1. OpenAI API server management
2. NPC management
3. Diagnostics and testing

With NPC-Forge now everyone can quickly build an NPC and share it with the community, those NPCs run on the CPU in any Linux machine, like the RPI Zero, responding in milliseconds. Imagine, now even your AC meter or your router can serve a conversational agent for free. This approach is also more democratic, your NPC will happily say something uncomfortable if you program it to do so, much better than corporate alignment filters and guardrails shaping public opinion, culture and language.

I ask for a bit of leniency: this is my first Python project, made in two months of passionate development. I am fully aware the code is not yet production-ready. I bet many Linux graybeards will curse me until the end of time because of the chain of commands TERMy sometimes emits; a lot of work must be done on the dataset and the source code to achieve safety and production readiness.

Consider that this is an early release to showcase what we may use in a not very distant future. If the shared effort of the community is focused on NPC-Forge and TERMy, I think they may provide us with more freedom and help us save money, electricity and time. If you liked this read and you agree with me, consider contributing to the project. Happy tinkering!

Or: Why do I always do things the hard way?

Jane Street periodically puts out challenges, and this one thoroughly nerd-sniped me and sent me down a month-long rabbit hole that I’m only now emerging from. This post is an overview of how I solved it with a combination of hard-headedness and sleep deprivation. It’s going to be decently technical, but in future posts I’ll go over the specifics of each step if people are interested.

For some background I’d recommend looking at the original post on the Jane Street blog here - Can you reverse Engineer an ASIC?

And if you ever want to read the (terrible) code I used for this challenge, you can find it at my github page here

Challenge Accepted

I have an engineering degree rotting away somewhere in my brain, so a lot of the words of the challenge are familiar. The challenge is to take an ASIC and work out what it does. For those unfamiliar, an ‘ASIC’ is an Application-Specific Integrated-Circuit, which is a fancy word for what we’d usually call a ‘Computer Chip’. Firms like Jane Street presumably design these to get extra performance relative to the equipment you can buy from a normal manufacturer.

In any case, the challenge is to take a ‘GDS’ file describing a chip, and work backwards to understand what it does, and then I guess maybe there’s a password in there or something. I didn’t, and still don’t, know what ‘GDS’ stand for.

There’s two parts to the challenge - one is a warmup where you’re given a lot more information (like the actual design of the chip), and the real puzzle where you’re given a firm handshake and a ‘good luck’ as you face the increasing prospect of not sleeping for the next three weeks.

What’s in the files?

For some reason, I like to do things the hard way so rather than doing any research I just started poking around in the files. I can see there’s some familiar words in them like like ‘clk’ (clock), ‘rst’ (reset) and ‘VGND’ (Ground Voltage) and ‘VPWR’ (Power Voltage).

And there’s a bunch of …. something with a prefix of sky130_fd_sc_hd__ followed by things that sound like logic element, like ‘or’ and ‘not’ and things like that. I guess that’s what I’ll need to pull out of the file?

I found there’s a really nice library ‘gdstk’ in python that seems to be able to read them. It tell me that there’s 27 elements on the warmup puzzle. A good start!

% python3 -c 'print(len(__import__("gdstk").read_gds("warmup/04_final.gds").cells))'
27

There’s also a ‘vcd’ file for the main puzzle, which is a text file, and I guess is a simulation input or output or something. I didn’t, and still don’t, know what ‘vcd’ stands for. I can see some suspicious entries in it that look like ASCII characters. I play around with it, writing a small C program, and get the output ‘TRY AGAIN’. Ah, so the circuit has messages in it somehow!

$ gcc what-is-this-thing.c && ./a.out
T R Y   A G A I N  T R Y   A G A I N

Ok we’re on to something

Getting Distracted and wasting my time. And my life.

Here we need to do a huge digression and of course build our own circuit simulator. For reasons.

You can skip this section. I sure wish I did.

Several days later

Ok so I built a circuit sim using sqlite3 as a driver. Quite neat really. But it’s quite hard to design circuits in Python! If only there was a language for describing hardware.

Several days later

Ok so I built a parser for my new language and now I can design circuits. But I need to test them! If only there was some way of scriptings inputs and validating outputs.

Several days later

Ok so I built a harness for my circuit simulator. But it’s really hard to visualise what it’s doing! If only there was… well you see where this is going

Several days later

Ok so I gave up on writing a wave form viewer and decided to just use ‘surfer’. But these gds files are hard to work with, how can I make that easier?

Several days later

Ok so I wrote a basic GDS viewer in raylib but I can’t get the blocks to sit quite the way I want to. So anyway, I realised I’m down too many tangents and it’s time to drop all of the custom software.

Ok we’re done with that section. Aren’t you glad you skipped it?

Focus, Chris, Focus.

The Jane Street blog actually points to quite a handy GDS Viewer, so I spent some time just looking at it real hard and hoping something would come to me. I was able to roughly annotate what I though were which inputs, and I could later confirm that by looking through the approximate locations of wires in the files. Because this was the warmup I could compare what I knew about the circuit against what I could see.

What do these files represent?

These files seem to have some sense of ‘layers’ of different types of material or something, I imagine it’s a bit like a big 3d-printer that has to be told where to move the print head, and at what depth it needs to put a new material. Maybe these files are close to the instructions to the machine? But rather than having arbitrary positions in vertical space they seem to have standard layers of standard widths so that simplifies things.

I wanted to prove that I could at least operate on these files, so I tried to extract the Jane Street logo on the upper right corner. Somehow this was way harder than I thought and I ended up extracting everything except the Jane Street logo? But whatever good enough, lets move on.

I also at some point work out that the library I’m using can extract the elements to SVG file formats, and it includes a bunch of text describing the parts of the elements. This will be key to actually understanding the challenge because I can maybe use that information to work out which parts are inputs and outputs.

Time to actually read about these elements

I’ve gotten as far as I can with guessing. Time to actually read some proper documentation. Looks like this is their official home, despite the ‘unofficial’ in the name - sky130-unofficial

The docs had the answers to many of my questions. Why do I always do things the hard way?

It turns out that this ‘sky130’ thing is like a … standard? Or something for making chips. I guess making chips is hard, and so it makes sense for there to be common design elements. Crucially it also contains the descriptions of what the elements do, which is easy for elements like ‘and’ that are probably an ‘and gate’ but less clear for a ‘o21bai’ which is a …. well don’t worry too much about that.

Using the information from the docs and the labels from the SVG I can now theoretically map specific geometry to the I/O of the circuit elements, which I guess will be the first step to turning it into a ‘real circuit’. I get really lucky here, in that my library has the ability to check if two elements overlap in 2d space (remember these gds files are actually a description of a 3d geometry).

I wasn’t sure how reasonable the assumption of the labels overlapping the correct locations, but it worked way better than I expected! I guess labels are already referenced on their centerpoint! It even picked up some geometry that isn’t visually connected so a visual inspection would never have revealed their connections. And looking at the total design’s IO ports, it’s so much less visually noisey.

I think I can make a graph now?

I think I have what I need now to extract a circuit from this gds file. This isn’t going to be easy. This thing has 1k paths and almost 17k polygons even after ignoring everything I don’t care about.

I need to find a way of finding things that are ‘touching’, which means that they are on adjacent layers and also overlapping.

My algorithm is pretty terrible, but it does the job for now. I also introduce a simplification step where I take all of the ‘wire segments’ and …. compress? or coalesce? them into a single wire. The logic is, that if two wires are touching then they’re actually the same wire from my perspective.

Luckily I spent several weeks grinding leetcode last year while unemployed so a few graph algorithms weren’t going to slow me down.

Many days later

The next few days of work were not easy. In my working log I have recorded that “By beating my bloodied face against the keyboard for several hours and cursing how long I’ve already spent on this, I’ve managed to nail down a tricky bug”. I’m not exactly sure what that bug was now, but I’m sure it deserved it.

I’ve started to be able to turn my network in to real descriptions of hardware in a language called ‘Verilog’, which also allows me to run basic simulations like checking that ‘turning this pin high makes that one go low’. I’m eventually able to extract all the components into a handful of spaghetti, and I spend time manually drawing out the connections.

I don’t use any tooling (other than excalidraw, my drawing program). I mostly just look at it real hard until things make sense. Again, I do things the hard way

Many Attempts on a Shift Register

Not pictured: Sanity

But in any case I now had an understanding of the major components of the warmup puzzle - two shift registers (that shift things), an adder (that adds things) and a comparitor (that compares things) and I work on trying to simulate the outputs. I know that the input needs to sum to be 496 as the comparitor is named comparitor496 so I just need to put in the correct sequence of bits to achieve that. That’s just simple maths, the hard part was trying to get all the various parts all working together in a single simulation.

If only there were some way of doing this that didn’t involve trading off my sanity for progress.

A few hour later and it’s done! I finally got this thing to work!

Waveform

It’s at this point I knew I had a chance of solving this thing, but it was a race against the clock, and my immune system was starting to give out.

On to the real puzzle

The real puzzle has many more component types (81 vs 20 or so) and many more of them (almost 10k vs 1k) so this won’t be easy. I was able to quickly get most aspects of my scripts working from the warmup steps, so long as I dropped all validation. Which is not ideal but it was only temporary. More annoying is that the process of extracting the circuit takes almost a whole minute instead of two seconds.

Initial work

I was able to get a little win by rearranging my wire segment gathering step so it is now 100x faster (3.4 second down to .03 seconds). It has byte-for-byte compatible behaviour so I’m pretty confident it hasn’t introduced any bugs. However the major slow step still swamp this improvement - finding all connected components takes almost a whole minute. Luckily I have a lot of confidence in that step after the nightmare of the warmup puzzle, so I don’t have to run it too often

Extracting the real puzzle

It took a long time, but I added implementations of all of the 40 or so new components that I need in the real puzzle by just manually copying them from the documentation site. In retrospect I’m sure I could have copy-pasted it from somehwere, but (in case you haven’t been paying attention) I like to do things the hard way.

After that, and some quality-of-life improvements around being able to add names or aliases to wires, I was able to build and run a simulation of the real puzzle. It didn’t work, but still, I think that means I’m in with a shot of solving this thing.

Is there a bug?

One annoyance I had is that I had to disable my validations, but it’s hard to make progress without validations as it’s easy to introduce bugs without noticing until hours or days later. So I went back to trying to turn them back on. For example I had a validation step that checked that all wires are actually connected to something.

I found in one section of my simulation that I had an undriven wire, meaning that its value was completely unknown to my simulator. That’s a bit strange really, because even if you don’t care about the value of a wire you’d typically just drive it to some known value rather than not connecting it at all. I assumed it was a bug in my pin-detection logic, but by visual inspection I could see that my code was correctly picking up a wire that’s only connected to two input pins.

Even stranger, the circuit has a connection on a neighboring pin that isn’t even an input or an output! Maybe there’s a bug here and it should be connected to one of the inputs? Given how little I understand, I sheepishly reported it to Jane Street.

Bug Report

Bug Report

The next day I had an email confirming that I was right! But luckily it shouldn’t have an impact on the actual results of the challenge. I quite sincerely think this bug report might be one of my coolest technical achievements.

Bug Response

Looking from a bird’s eye view

I spent a long time mapping out sections of subcircuits and the wires connecting them, and things started to fall in to place. I worked out that the section that feeds the ‘success’ wire has 6 wires, so now the challenge is slightly reduced to ‘how do I make those 6 wires go high?’, and luckily it seems like two of them do it after a certain number of clock cycles, so really it’s only 4 wires.

Excalidraw of circuit

I can see other patterns too. The left-most subcircuits seem to act like a signal generator which then feeds in to other sections of the circuit. So maybe the ‘password’ is hidden inside the structure of these elements?

Combining the three, I can see it gives 121 or 120 clock transitions before the output goes high. That matches the waveform in the provided example, so maybe you need to have the password correct in 120/121 clocks otherwise you get the message?

This section seems to feed the rest of the circuit, so this might be the start of a clue.

I was now able to get each sub-section to run in a simulation but not really do anything useful. I then started working on connecting all the sub-components into one large circuit.

It turns out I’m an idiot.

I wasn’t able to get my overall sim working at all for 2 or 3 days, even though I’d quite thoroughly tested each sub component. Well, it turns out that I had forgotten to set the ‘reset’ pin, so the whole thing was effectively disabled, kind of like forgetting to turn the car on and wondering why you’re not going anywhere.

I fixed that and immediately saw ‘TRY AGAIN’ as expected. Success!

Even more interesting is, I deleted the input I was feeding to the circuit and I found it had other messages too:

Input Output Wrong Answer TRY AGAIN All 0’s EMPTY SKY All 1’s BIG BANG Correct Answer TBD

The doldrums

I’ve now reached the hardest part of this challenge. I’ve found that the input to this circuit is 120 bits, and I have no idea how to progress. I considered exhaustively checking every input but that would unfortunately take more time than any of us have on this planet.

Wire-by-Wire

I follow the output wire back directly, but the complexity of the inputs are too much for me. I need some new approach. At some point in my notes I ask the question ‘what if I run the simulation in reverse?’, and I start mulling on this idea.

The thing is, I know where I want a signal to be and I know what the inputs need to be at that point.

So then if I take one step back in time I can re-write the desired output as a functions of the previous step.

This is like a recurrance relation, but I actually know what I want the output to be on step 120, and I know that the circuit starts with all outputs at zero. So theoretically this is solvable in some mathematical sense.

Hopefully the picture below explains a bit better what I mean

Recurrance Relation

I focus on a shift register component as it’s closest to the one I solved in the warmup puzzle (which is a nice touch of pedagogy, so thank you Ben and Anish!). There’s some tricky constraints actually, I can tell it depends on previous values in the shift register, this probably needs some constraint solver to solve. Constraint solvers are notoriously complicated to understand, but luckily I know the perfect tool

On using a spreadsheet to write verilog

I’m sorry for the abomination that I’m about to show you.

Verilog in gsheet

Yes, that’s a spreadsheet that I used to write verilog that I then fed in to my simulated circuit. Surprisingly, under the hood spreadsheets are actually incredibly sophisticated constraint solvers. I dumped the output into a Verilog file, and ….. it worked! At least for two wires. It does look like this approach will be underpowered in general because it relies on me eyeballing the output and toggling bits here and there until all my checks go green. But it did prove that this approach of solving it backwards has legs.

It’s time to bring out the big guns and learn to use a constraint solver.

This …. isn’t as hard as I expected?

I remembered reading about constraint solvers on Hillel Waynes blog (who has a new book out you should go buy! I’ve got my copy), but I’d always been intimidated because they use big words like ‘constraint’ and ‘solver’ and I just need a thing to solve the constraints in my - ooooh I get it!

I ended up using a tool called ‘z3’. It’s kind of magical? Every time it finds a solution I get a surge of joy. You tell it things like ‘This wire can never be low’ or ‘This wire has to be high at step 120’ and it either finds how it can do that, or tells you it can’t be done. I was able to give it thousands of constraints in the end and it would find solutions in the blink of an eye.

Debugging it is a bit of a nightmare though, and mostly seems to involve me thinking real hard and deleting lines until it starts working again. I did get a bit of a sense for the sort of outputs it liked to produce - in particular if I didn’t specify starting points it would just choose whatever was convenient for it (and inconvenient for me)

Annoyingly I did a lot of the translation work from my circuit in to z3 by hand. I’m not quite sure why I did it that way other than I had gotten sick by this point and I didn’t trust myself to write a transformation script.

I went one-by-one on the wires I cared about. There are about 24 that I need to be high at the same time and I was able to get 22 of them relatively easily in isolation by a combination of using the solver and sometimes just guessing a bit and validating them in isolation.

It turns out I’ve done this the hard way, as is characteristic.

It turns out the structure of the inputs to many of the element appears to just need two pulses at a multiple of 11, determined by the value of a counter. If I’d just looked at the inputs a bit longer instead I might have worked it out, but I was in too deep looking at the lower layers rather than looking around at what I could see right in front of me.

The Answer. It’s done

I now combined all of my constraints in to a single giant script and set about squashing the bugs. There were a few, but by 10pm instead of an error I got the following output -

% python3 solver.py
Solution!
verilog saved to 'out.txt'

My hands started shaking because by this point the only way it could have a solution is if it had the answer.

I loaded it in to my simulator, run it, and there it is. The answer - (* TWO STARS *)

Two Stars

I emailed Jane Street, and the next morning I had my confirmation so I can now add it to my table of outputs -

Input Output Wrong Answer TRY AGAIN All 0’s EMPTY SKY All 1’s BIG BANG Correct Answer TBD (* TWO STARS *)

What next?

Well I don’t really know what to work on next, I really enjoyed this challenge but I also have other hobbys such as ‘getting to bed before 3am’. But Jane Street did mention they might have a new challenge coming out in a couple of months, so stay tuned!

If you have any suggestions for fun projects, let me know either on Hacker News or by email.

And if you’re in Sydney and found this interesting, get in touch and we can grab a coffee.

Fairphone’s CTO explains how and why the Dutch company builds a different kind of smartphone.

You can fully disassemble the Fairphone Gen 6+ in about 20 minutes. Credit: Ryan Whitwam

Smartphone longevity didn’t used to matter. In the past, before you could wear out or break a phone, there was always some shiny new thing to buy. Today, we expect our smartphones to go the distance, but they’ve also become less repairable and, in many cases, more fragile. Fairphone, a Dutch smartphone maker that has just entered the US market, thinks about phones differently.

The new $650 Fairphone Gen 6+ is designed both for longevity and easy repairability. There are trade-offs to this approach if you’re used to the standard glass and aluminum sandwiches filled with glue, gaskets, and teeny-tiny screws. But the drawbacks could be worth it for the right buyer. Fairphone CTO Chandler Hatton told Ars that Fairphone’s goal is to provide a compelling mobile experience while also enabling the user to “fully own” their device. At the end of the day, this is what a lot of people say they want in a smartphone.

Take it apart, put it back together

These days, Google, Samsung, and Apple support phones with software updates for the better part of a decade, but will the hardware last that long? And what happens when it needs a repair? You may be out of luck or out a lot of money, but Fairphone prioritizes the self-repair experience.

“We’re doing something that was long thought to be nearly impossible,” said Hatton. “Which is delivering high-performing modular smartphones that can last for a very long time.”

The Fairphone Gen 6+ has a 6.31-inch OLED screen, which is, of course, fully replaceable. Credit: Ryan Whitwam

Fairphone designs devices to be sustainable, focusing on avoiding conflict minerals, using recycled materials, and paying workers a living wage. Fairphone says it doesn’t want to sell you a bunch of phones, just one that you can keep using even if something breaks.

“Our goal is that every single person that purchases a Fairphone uses it for at least five years, and we track that as a KPI [Key Performance Indicator],” said Hatton.

The standard way to design a modern smartphone is to cram as much as you can into an aluminum and glass sandwich, with the expectation that it will be assembled once in a factory and never opened by the buyer. Devices rely on glue and awkwardly placed screws to accomplish this, making the internals a little like metal spaghetti.

The Gen 6+ is designed so that anyone can replace parts, reducing e-waste and potentially saving consumers a lot of money. If you’ve had, say, a Samsung Galaxy phone for a couple of years and need to replace the screen or USB port, the cost might be higher than just buying a new phone.

“There is an incentive in terms of planned obsolescence to replace your device,” said Hatton. “On the one hand, it’s a good way to keep selling devices, but that’s simply not the proposition that we have.”

That means designing the phone differently—it’s not just a matter of skipping the glue. Inside, the Fairphone Gen 6+ is clean and orderly. It starts with a pair of T5 Torx screws exposed on the back of the phone. After removing those, the back cover slides off. With the same driver, you can extract the battery, camera modules, USB-C port, display, and more. In all, the phone supports user replacement of 12 different parts with just that one (included) screwdriver. One drawback is that the modular approach makes the phone a millimeter or two thicker than most glued-together phones.

The phone comes with a tiny screwdriver, but any T5 torx will work. Credit: Ryan Whitwam

The battery stares you in the face once the back panel is opened. You’ll have to remove a few more screws to get it out, but quick swapping isn’t the goal here—this is about longevity.

“We know that after about three years, it will be wise to replace your battery with a new one,” said Hatton. “Batteries aren’t meant to last forever, but your phone on the whole can last a lot longer than a battery.”

While the Fairphone is designed to be disassembled, what about the long haul? The Fairphone 6+ is mostly plastic rather than metal like a Pixel or iPhone. The phone still manages to feel solid, though, thanks to its internal metal frame, and the company has worked to ensure the device doesn’t become progressively less sturdy as you tinker with it.

“When we’re in our product development cycle, we introduce tests that are specifically dedicated to disassembly and reassembly,” said Hatton. “So we’re looking in part at the robustness.”

Robots work the assembly line, but humans are less predictable. Hatton pointed to tests that examine, for example, what happens when someone over-tightens screws while servicing their device. Does it warp the casing? Damage any nearby components?

Hatton said it takes her 15 minutes to fully disassemble a Fairphone Gen 6+, but she did have a hand in designing it. That said, it shouldn’t take a novice much longer. After a couple of minutes perusing Fairphone’s documentation, I was able to take the phone apart and remove all of the user-serviceable components in about 20 minutes. Everything went back together without issue and still works perfectly, with no new gaps or wobble.

The process is pretty intuitive, with most of the parts held in with flat board-to-board cable connectors. Just pop them off with a spudger or your fingernail, and the component lifts right out. There are a good number of screws to remove to get all the way down to the metal frame and screen, but again, they all use the same T5 Torx bit.

Specs at a glance: Fairphone Gen 6+ ($650) SoC Snapdragon 7s Gen 4 Memory 12GB Storage 256GB plus microSD Display 6.31-inch 1116×2484 LTPO OLED, 10–120 Hz, 1400 nits Cameras 50 MP f/1.88 primary, 13 MP f/2.2 ultrawide, 32 MP f/2.0 selfie Software Android 16 Battery 4415 mAh removable battery, 30 W wired charging Connectivity 5G, LTE, Wi-Fi 6e, Bluetooth v5.4, SIM+eSIM Measurements 156.57 mm × 73.28 mm × 9.6 mm, 193 g Colors Cobalt Blue, Horizon Black, Forest Green

Glass backs are common on smartphones because they’re good for radio performance, and they add significant rigidity to the design. But they’re also easy to crack and difficult to remove (they’re almost always glued in place). Naturally, the only glass on the Fairphone 6+ is covering the 6.31-inch 1116 x 2484 OLED display, which is fully replaceable. This is probably the most challenging component to swap, but even this isn’t too bad. The screen is held in place by a handful of screws and has a generously long ribbon cable attachment, making a swap much less frustrating than your typical smartphone.

The OLED is about what you would expect for this price range—the resolution is more than sufficient, and the colors are great. The brightness is good enough to be legible outdoors, but at a mere 1,300 nits peak brightness, it’s harder to see than the displays you get on phones like the Pixel or Galaxy S26 that are a few hundred more expensive. Good luck replacing those displays on your own if you get a crack, though.

What specs make the cut?

Smartphones have become more powerful over the years, but their designs have also been streamlined. Headphone jacks and microSD card slots are now rare, and even the SIM card slot is quickly fading away. OEMs often cite the space constraints when dropping these features.

“There’s a reason that most phone manufacturers prefer slightly larger footprints—because you can fit more stuff in there,” Hatton said. “So yes, it is legitimate if phone manufacturers are saying, ‘Hey, we dropped this feature to save space inside the device.’”

The Fairphone retains some of these elements, but not because there’s a surplus of space, Hatton said. The Fairphone 6+ still has a microSD slot and physical SIM card because people want them. These features don’t come free, though. In addition to the space constraints, adding more components adds to the price and complicates supply chains. That’s another reason some OEMs have removed features.

Being modular means the Fairphone is a little thicker than most smartphones. Credit: Ryan Whitwam

The Fairphone Gen 6+ plays to picky smartphone and DIY enthusiasts, but there’s still no headphone jack. Hatton notes that the team hears from a small but vocal cadre about headphone jacks every time it starts planning a new device, but it hasn’t made sense to include one in recent phones.

“In terms of how to actually get [a headphone jack] into the device, it is quite difficult,” Hatton said. “It’s a relatively large hardware component, but it’s not just the component itself. It’s also where it needs to be. You know, you’re not going to put the headphone jack in the middle of the back of the phone. You also need to make sure it attaches to the right things on the inside, and because we’re Fairphone, you need to make sure it’s repairable. So when we look at that total picture, we assess the needs of our customers to fulfill some other wishes at the expense of the headphone jack.”

Looking at spec sheets side-by-side, the Fairphone also lacks something that many of today’s phones have: IP6X water resistance. An upshot of making non-repairable phones that are chock-full of glue is that they’re relatively easy to seal against water intrusion. With an IP6X rating, a phone can be fully submerged in water for up to 30 minutes, at least in theory.

The Fairphone Gen 6+ is only rated as IP55, which will protect it from splashes. That could be enough, though. “Our phones are designed for what people need on a day-to-day basis,” said Hatton. “How often is it that people would like to take their hardware underwater? I think the answer there is less often than some manufacturers would have you think.”

While it might be comforting to think you could drop your phone in a pool, that’s still risky. OEMs don’t warranty the water-resistance of their phones, and if you’ve made any repairs, it’s possible the sealing of that difficult-to-open device was compromised. Hatton notes that it wouldn’t be impossible to make a repairable phone that’s also IP6X, but you’d have to design around that in numerous ways.

“There are a number of things that you need to weigh against a higher IP rating,” Hatton said. “You can achieve it in a very small form factor with higher costs, or you can achieve it with a larger form factor—you could increase the Z dimension and perhaps also the other dimensions, and that way you could create all sorts of gaskets and other things. But we assess the whole landscape and say, ‘Hey, the customer doesn’t want a phone that’s a brick.’ They also don’t want a phone that’s incredibly expensive. So within those boundaries, what IP rating meets their needs?”

It’s a trade-off, but it’s one that many people would probably make in the name of repairability if given the choice.

Planning for the future

The Fairphone Gen 6+ is similar to the Gen 6 that launched in Europe last year, but there are a few notable changes. The new phone has a slightly upgraded Snapdragon chip, and it has more memory than the last Fairphone at a time when AI has driven up costs considerably.

“We decided to increase the RAM to 12 gigabytes,” said Hatton. “This is something that I think is a little bit unique, given the current circumstances in the consumer electronics industry. But the reason that we did is that it really underscores the value proposition of longevity that we’d like our customers to enjoy when they purchase the Gen 6+.”

Fairphone boosted RAM to 12GB for this release. Credit: Ryan Whitwam

Google, meanwhile, is catching some well-deserved flak for regressing from 16GB to 12GB of RAM in its latest Pixel phones, which start at $900. Samsung is also sticking with 12GB of RAM in its $2,000 foldables. And all those phones devote a lot of memory to AI services that not everyone cares about. The Fairphone has the Gemini app installed like all Google-certified Android devices, but the company has yet to create any on-device AI services of its own. That’s on Fairphone’s radar, but the team is taking a measured approach.

“We have not immediately jumped onto the bandwagon of creating AI features without really understanding what the use scenario is and what the customer really wants,” said Hatton. “We see that people are quite interested in understanding how their data is used and having control over their data and privacy. That means that as we continue to use more AI in all sorts of different settings, we’ll continue to work on AI features for our devices that focus on these aspects that are important.”

Fairphone has been offering devices with generous support windows for years. The Fairphone 3, which launched in 2019, just reached end-of-life a few weeks ago. The Gen 6+ will be supported through 2033 with software updates and replacement parts.

Hatton says that multiple factors go into determining the length of support. The availability of hardware in the supply chain is part of it, but it becomes impossible to update devices once vendors like Qualcomm stop supporting the underlying firmware. Seven or eight years is the functional limit for any smartphone due to vendor support, so it’s impressive to see Fairphone in the same range as the likes of Google and Samsung. It really can’t do more than it’s already doing here.

Is the Fairphone the right phone?

At $650, the Fairphone feels like a good deal in 2026. Maybe a year or two ago, the device wouldn’t have seemed as competitive, but with price increases and RAM regressions becoming standard, Fairphone comes out looking much stronger with the Gen 6+. It has a solid mid-range Snapdragon chip, ample storage (with a microSD card slot), and 12GB of RAM, which is still flagship territory.

There’s also something to be said for knowing that your phone is repairable if something goes wrong, and when the time comes to replace the battery, you can do it yourself in a few minutes. Fairphone is committed to keeping all these parts in stock for the duration of the phone’s support window, which runs through 2033.

The Fairphone may not be everyone’s style, but I like the utilitarian vibe. My design complaints are fairly limited and minor: the volume buttons are too low, and the power button (with fingerprint sensor) is too hard to find by feel.

Fairphone’s version of Android is light on bloat. Credit: Ryan Whitwam

The modular design allows for a little fun in the form of accessory back panels. You can swap them just by removing the two external screws. There’s a finger loop back (below), a card holder, and a lanyard that works with any of the backs. Hatton notes that the accessories also invite users to open up the phone to see how easy it is, something Fairphone recommends people get familiar with even if they don’t have any accessories to swap—it’s like knowing where the spare tire is in your trunk.

The Fairphone Gen 6+ runs a minimally customized build of Android 16, so it’s a bit behind the latest and greatest. Thankfully, Google doesn’t limit as many features to the latest builds of Android anymore. It has almost no bundled software outside of the standard Google apps, which is nice to see, but if you’re hoping for a phone that’s crawling with snazzy software features, this is not it.

Fairphone sample with dog

Medium outdoor light

Fairphone sample fair

Outdoors overcast

Fairphone sample UW stage

Ultrawide

Fairphone sample UW nature

Ultrawide

Bright outdoor light

Fairphone sample dark shelf

Night mode

One of Fairphone’s few software customizations is called Moments, which you can toggle with the brightly colored side switch. Moments can help limit distractions by hiding most of your apps behind a minimalist UI. It’s just a full-screen app overlay rather than a completely custom home experience, though. If you don’t fancy the digital well-being approach to mobile tech, you can remap that switch. Using it as a flashlight toggle is nifty, for example.

The camera may be the biggest compromise if you switch from a Google or Samsung phone. The hardware is typical for the mid-range, with a 50 MP Sony 700C joined by a 13 MP OmniVision OV13B10. That third lens on the back is actually a window for a time-of-flight sensor that helps with focus. With ample light, both rear sensors produce good images, and the primary even does fine in some more challenging conditions.

Capture speeds are long, though, making it hard to get clear images of moving subjects. Colors look a bit flat, too, and autofocus speed seems on the slow side. There’s a 32 MP selfie camera, which looks a touch dimmer than most devices in this price range.

The Fairphone Gen 6+ (left) might not be as sleek as the Pixel 11 Pro XL (right), but you don’t need a hairdryer to open it up. Credit: Ryan Whitwam

With support increasing for making electronics more repairable, other companies may need to start moving in Fairphone’s direction. In Europe, regulators are preparing to require removable batteries, and more US states are enacting right-to-repair laws. The Fairphone CTO stresses that other OEMs have what they need to make phones more repairable.

“We’re producing our phones on the same production lines as our competitors, and often with many of the same components,” said Hatton. “It’s actually quite a small industry when you’re in it, and there is very little room for one of our competitors to say it’s impossible when on the next production line over it is happening.”

The Fairphone Gen 6+ is available directly from Fairphone, as well as on Amazon. It’s unlocked and works on both AT&T and T-Mobile.

OpenTrailPaper is firmware for the LilyGO T5S3 4.7" E-Paper PRO. It shows ride data and offline maps, follows GPX routes, records FIT files and connects to Bluetooth sensors. You buy and protect the board yourself.

Device walkthrough

Each item shows the screen it describes. Use the orange touch target on the device to move between related screens.

Use the app for setup and file transfer.

The iOS companion can plan and transfer routes, build offline maps, copy recorded rides, change settings and install firmware updates over Bluetooth. The head unit does not need the phone during a ride.

View in the App Store → Free · iPhone · iOS 17 or later Android is in closed beta — ask in the Discord to join.

Plan a routeSearch for a destination, check the proposed route and send the GPX file to the device.

Copy recorded ridesTransfer rides from the device, then review the map, distance, power, heart rate and estimated ascent.

Settings and updatesSet FTP, timezone, units and backlight level, or install a firmware update over Bluetooth.

What works without a phone

After routes and maps are loaded, the head unit can record and navigate by itself. There is no account or subscription. The app is used when you want to prepare or transfer data.

On the device — every ride

• GPS tracking with speed, distance and a live map
• Records each ride to a .fit file on the SD card
• Turn-by-turn prompts along a loaded route
• Runs structured workouts from .erg or .mrc files
• Pairs with heart-rate & power sensors over Bluetooth
• Works without a phone or data signal once maps and routes are loaded

In the app — setup and transfer

• Plan a route and send it to the device
• Build offline maps for a new area
• Create workouts and arrange the device screens
• Pull rides off the device and review them
• Change settings and update the firmware

Currently supported on one board

OpenTrailPaper currently targets the LilyGO board below. It is a development project, not a finished or weatherproof retail product.

LilyGO T5S3 4.7" E-Paper PRO↗

ESP32-S3 · 16 MB flash · 8 MB PSRAM · 960×540 e-paper · BLE 5

Strengths

• A 4.7" e-paper panel that is readable in direct sunlight
• An SD card slot for offline maps, routes, ride files and logs
• GPS, capacitive touch, a front light, battery and USB-C on one board
• Bluetooth 5 for heart-rate, power and cadence sensors
• Firmware can be installed from a desktop Chromium browser over USB

Tradeoffs

• No pressure sensor. There’s no barometric altimeter, so climbing is derived from elevation baked into the map tiles rather than measured — total ascent is an estimate.
• Basic GPS. The receiver works, but a modern multi-band module would lock on faster and hold a fix better under tree cover or between buildings.
• No magnetometer. Without a compass the map can only orient from your direction of travel, so it can’t point the right way while you’re stopped.
• Measured baseline: about eight hours. A 1,500 mAh build ran for roughly 7.4 usable hours with the front light off. Power work is ongoing, so newer builds may differ.
• Weak hardware buttons. Most interaction goes through the touch panel, which is fiddly with winter gloves or in the rain.
• No waterproofing. The board ships bare with no seal or IP rating, so it needs a case or a bag of its own before you ride it in the wet.

Got a better board in mind?

Suggestions and pull requests welcome

A better target board would include a barometric altimeter, multi-band GPS, magnetometer, larger battery, usable hardware buttons and a weatherproof case. If you know of one, open an issue. Board ports are also welcome in the source repository.

Install the firmware and prepare an SD card.

The setup page flashes the board over USB and can build basic offline maps. It requires a desktop Chromium browser; the iOS app produces maps with elevation data.

Read setup instructions →

LOCATION

625 Market Street, San Francisco, CA

YEAR BUILT

Early 1907, after The Great 1906 San Francisco Earthquake.

CHALLENGE

Untangle a perplexing criss-cross cable-designed gearless basement traction elevator system from the early 20th century and convert it into a modern, overhead traction variable frequency-controlled AC gearless system.

SOLUTION

Completely re-engineer the existing offset basement design. Replace with overhead, modern, compact, energy-efficient, gearless AC machines, counterweights, and rails. Install microprocessor AC (VVVF/AC drives and controllers.

Elevator World Project of the Year Winner, for elevator modernization!

San Francisco in 1907. The City is still shaken from the aftermath of one of the most significant earthquakes of all time. However, The City is surging back to life; rising from the rubble. New building projects are in motion – modern structures will soon line Market Street.

Today, The Metropolis Trust Building sits amongst the most expensive real estate in San Francisco. 625 Market is a designated Category 1 Historic Landmark with a vertical transportation system still anchored in the past –a retrofit of machinery installed over 100 years ago.

21st century safety concerns meet turn-of-the-century building techniques. And there’s no app to solve this one. The elevator systems were all operating well beyond their expected life.

Situation

Project parameters included upgrading the rail systems to bring them up to modern seismic code. New pushbutton and signal fixtures, and modern cab interiors would also be added.

Elevators were not operating reliably –
issues with machine bearings and motor commutators kept cars out of service. In fact, car #1 had been intentionally disabled due to reliability concerns.

Building Management was intent on tenant satisfaction, safe operation, and improved structural integrity, as the historic building approached its second century of operation.
Enter Star Elevator. Despite the project’s inherent complexity, the team was not afraid to roll up its sleeves to solve the 15-story challenge.

The criss-cross crisis

First order of business was untangling the tricks of 1907 tradesmen – including a confounding criss-cross cable system.

This sketch created by John Sellen of JE Sellen Consulting illustrates the unique challenge of this project.

The elevators had a very unique roping configuration. Due to the placement of the machines under the hoistways, and the need for proper rope lead off of the overhead sheaves, the counterweights did not run in the same hoistways as the cars. This makes for a long, complicated rope scheme – each car had over ¾ of a mile of hoistrope!

Unique original roping configuration

Confounding original criss-cross cable system.

To further complicate matters, there were no building blueprints available. So the team turned to Rich Blaska from RCB Elevator Consulting, LLC. to draw up a detailed plan for everyone to follow.

Design drawings by Rich Blaska of RCB Elevator Consulting, LLC.

Execution

The focus was on job sequencing and scheduling. It was important to keep the building in operation, and keep an elevator running reliably and safely at all times.

Due to the unique rope configuration, it was necessary to shut down two cars at the same time. One car would have to service the building for months, before a modernized car was completed and returned to use.

Every step of the modernization process was a challenge. The Metropolis Trust Building is located on one of the busiest corners in San Francisco; so there was no chance to use cranes. And the building itself offered limited access; there was no loading dock or service entrance. All equipment had to enter through the front door – including 20’ pieces of reinforcing steel and 4,000 lb gearless hoist machines.

Hoisting new equipment up through elevator hoistways because of limited access.

The cabs themselves were disassembled to provide a platform so that the hoist machines could be brought up through the existing hoistways. The machines were set in position 40 inches above the deck in order to achieve the proper traction angle on the drive sheaves.

Outcome

The elevators are now in standard configuration. The new machines are overhead traction and the counterweights run in the same hoistway as the cars. This layout offers improved long-term safety, reliability, and system serviceability.

Cost Savings / Efficiency

• Power consumption is down 45% - 50% annually.

Performance Improvements

• The new system eliminates three AC / DC converters.

This modernized configuration offers improved speed, long-term safety, reliability, and serviceability of the
system and a significant energy savings.

Download PDF of Story

Elevator World Project of the Year Winner!

For well over a decade, copyright holders have used U.S. federal courts to unmask anonymous BitTorrent users.

Adult film producer Strike 3 Holdings has turned this into an industry of its own, filing thousands of John Doe lawsuits every year.

In most of these “John Doe” cases it subpoenas the Internet provider for the subscriber’s name, offers the alleged pirate a settlement, which effectively ends the case. This process is then repeated over and over.

Last summer, the company took aim at a much larger target. Together with Counterlife Media, Strike 3 sued Meta, accusing the tech giant of downloading thousands of its films via BitTorrent to train AI models. With 2,973 films at stake, the case could be worth up to $446 million.

This multi-million dollar case is now running into one of Strike 3’s routine “John Doe” lawsuits.

According to a motion filed last week, an anonymous pirate behind a residential AT&T connection is an executive at Meta’s Reality Labs division, which develops the Quest VR headsets.

From John Doe to Reality Labs Exec

The John Doe case started in March, when Strike 3 filed a complaint against the subscriber of IP address 162.192.7.34 at the same California federal court. In April, Magistrate Judge Virginia K. DeMarchi granted a subpoena to AT&T, noting that the name should not be publicly disclosed.

After AT&T shared the information, Strike 3 says its investigation revealed that the subscriber is an executive in Meta’s Reality Labs division. Citing his LinkedIn profile, the company notes that he has worked at Facebook and Meta for more than a decade.

The executive’s name and title are redacted, as shown below. Meta has asked the court to keep them under seal, as it did earlier for two other individuals named in the Meta case.

From the attorney’s declaration

However, Strike 3 argues that this is no ordinary home pirate, using the timing of the downloads as evidence. On March 20, 2025, the porn producer’s general counsel first emailed Meta’s lawyers with forensic evidence of BitTorrent activity on the tech giant’s corporate IP addresses.

“Just hours later, Strike 3 first recorded BitTorrent infringement on John Doe’s residential IP Address,” the motion reads.

“This may suggest that Meta desired to shift infringing activity to this hidden residential IP Address in order to prevent further detection,” Strike 3 adds.

Timing

Strike 3 sued the John Doe a year later. Only then, it says, did it find the alleged connection to the Meta case, which brings us back to the present day.

Nearly 20,000 Files

In addition to the timing, Strike 3 uses the number of downloads in the John Doe case as an argument. The company logged all BitTorrent activity detected from the executive’s connection, which was nearly 20,000 files.

This includes VR adult titles made for Meta’s Quest headset. Strike 3 suggests the downloads are consistent with work to make the headset compatible with adult films.

As recently as August 25, Strike 3 says it recorded more than 150 daily downloads, from multi-language “Mega Packs” of TV shows, movies, software and books to what it describes as AI-generated pornography and VR adult films. That included nearly a dozen of its own titles.

“In short, this is a lot for one person to torrent on an average day, particularly one who has a demanding job,” Strike 3 writes. The company believes the pattern makes more sense as AI training data or research.

It’s a lot

This is not the first time a Reality Labs employee has surfaced in the case. Earlier this summer, Meta confirmed that a former data engineer at the division was behind a Comcast connection linked to 97 films.

With its latest motion, Strike 3 asks U.S. District Judge Eumi K. Lee to relate the John Doe case to the Meta lawsuit, so that both proceed before the same judge. On paper, the request could streamline the court cases, by avoiding depositions and discovery.

However, the motion goes further than that as it would also turn executive’s home downloads as evidence in the $446 million suit.

If the cases are related, Strike 3 plans to amend the John Doe complaint to name Meta directly, argue that the executive is jointly liable, and move to compel Meta to appoint a Reality Labs custodian and hand over its torrenting records.

Meta: ‘Nothing Ties’ Downloads to Company

This week, Meta responded to the motion to link the cases. Officially, the company takes no position yet, as it can’t investigate whether the subscriber is even an employee without knowing his name. However, even if the subscriber is who Strike 3 claims, Meta argues that nothing ties the downloads to the company.

“They simply assume that the Subscriber is responsible for everything done on the IP address, and then leap to the additional, similarly unsupported assumption that he did it for Meta,” Meta writes.

The tech company leans on a common defense in BitTorrent piracy lawsuits, stressing that an IP address doesn’t identify the infringer. Judge DeMarchi flagged the same point when she allowed the subpoena.

Meta also flags a contradiction in Strike 3’s theory that downloads were switched to the home connection hours after the March 2025 warning. Strike 3’s own complaint alleges that Meta’s “off-infra” activity started in 2018, and that downloads on corporate IP addresses continued long after the notice.

“Plaintiffs’ new theory cannot be logically reconciled with those it is already pursuing,” Meta writes.

Meta has used the personal use explanation before. When a different Reality Labs worker, a former contractor, surfaced in the Kadrey case, Meta said its investigation showed his downloads were personal and unrelated to his work.

Whether Judge Lee agrees to link the John Doe case to the $446 million Meta lawsuit has yet to be seen. For now, the Reality Labs executive remains anonymous, even to Meta.

—

A copy of Strike 3’s motion to relate the cases, filed at the U.S. District Court for the Northern District of California, is available here (pdf). Meta’s response can be found here (pdf).

Substantial majorities of Republicans, Democrats and independents agree

WASHINGTON, D.C. — Americans’ perceptions of government corruption in the U.S. are at their highest level in 20 years, with 89% of U.S. adults saying it is widespread. That figure is up 10 percentage points from last year and well above readings in the 72% to 79% range between 2010 and 2025.

Democrats’ perceptions of government corruption have risen the most sharply since 2024 compared with other party groups. In former President Joe Biden’s final year in office, 57% of Democrats said corruption was widespread in government; that rose to 76% in 2025, the first year of President Donald Trump’s second term, and reached 91% this year. The figure among political independents (90%) aligns more closely with Democrats’ than with Republicans’ (83%) and is up 12 points since 2024.

Republicans’ views of corruption have changed far less in the same period. For the past two years, about eight in 10 have said corruption is widespread, broadly in line with 2024, when 87% said the same.

Although strong majorities of Republicans and Democrats perceive government corruption as widespread, it is likely for different reasons. Democrats’ perceptions appear closely linked to which party controls the administration. Republicans’ greater consistency on this measure — despite the 2024 election delivering them the White House and Congress — suggests a more underlying view of government corruption that depends less on the party in power.

Before Recent Increase, U.S. Already Outranked Other Advanced Economies

The U.S. has increasingly diverged from other advanced economies in perceptions of government corruption, based on Gallup polling across the 38 member countries of the Organisation for Economic Co-operation and Development. The median level of perceived corruption among OECD countries has fallen from 69% in 2009 to below 60% since 2022.

Full data collection for 2026 is not yet complete in all countries, so the closest comparison across the OECD is from 2025, when a median of 59% said corruption is widespread in their government.

In the early years of this trend, countries such as Greece, Hungary and the Czech Republic all saw scores above 90%. But over time, the highest levels of perceived corruption across the bloc have gradually fallen, reaching 79% in 2025 — placing the U.S. atop the OECD rankings for the first time, even before the additional 10-point increase within the past year.

By 2024, there was already a 15-point gap between the U.S. and OECD countries on this metric, but that rose to 20 points in 2025 as U.S. perceptions of corruption increased six points to 79%, compared with 59% across the OECD. The gap between the U.S. and the OECD median could potentially be even wider this year.

Since 2023, only four countries out of the 132 in which Gallup has posed this question annually have scored nominally above the 89% recorded in the U.S. this year: Lebanon in 2024 (92%), Peru in 2025 (92%), and Ghana and Nigeria in 2024 (both 90%).

Perceptions of Corruption in Government Outstrip Those in Businesses

Each year, Gallup asks the world about corruption in two contexts: government and business. The two are typically strongly related. If people think corruption is widespread in their national government, it is likely that they think the same about businesses in their country. But the U.S. increasingly bucks this trend.

Americans’ perceptions of business corruption have also increased this year, by eight points to 71%. That is 18 points lower than perceptions of corruption in government, the largest gap between the two types of corruption seen in the U.S. trend. By contrast, between 2006 and 2025, perceptions of government corruption averaged 11 points higher than business corruption. Across Gallup’s trend since 2006, few countries have recorded larger gaps than the current U.S. gap in relative perceptions of government versus business corruption.

Bottom Line

Perceptions of government corruption are now higher in the U.S. than at any point in the past two decades and outpace most other countries, including advanced economies. While perceptions of corruption in business are also elevated, government corruption is seen as significantly more widespread.

In a country where many are polarized across a wide range of issues, this is one case where bipartisanship reflects shared alarm as much as shared consensus. In fact, it is the near convergence of U.S. partisans on the issue — with Democrats’ concern about government corruption now only marginally higher than Republicans’ — that has lifted the U.S. figure to its record high.

Stay up to date with the latest insights by following @Gallup on X and on Instagram.

For complete methodology and specific survey dates, please review Gallup's Country Data Set details. Learn more about how the Gallup World Poll works.

Survey Methods

These results are based on telephone interviews conducted May 1-June 10, 2026, with a random sample of 1,000 U.S. adults, aged 15 and older. For results based on the overall sample, the margin of sampling error is ±4.1 percentage points at the 95% confidence level.

All reported margins of sampling error include computed design effects for weighting. In addition to sampling error, question wording and practical difficulties in conducting surveys can introduce error or bias into the findings of public opinion polls.

Quad9 is a free service that replaces your default ISP or enterprise Domain Name Server (DNS) configuration. When your computer performs any Internet transaction that uses the DNS (and most transactions do), Quad9 blocks lookups of malicious host names from an up-to-the-minute list of threats. This blocking action protects your computer, mobile device, or IoT systems against a wide range of threats such as malware, phishing, spyware, and botnets, and it can improve performance in addition to guaranteeing privacy. The Quad9 DNS service is operated by the Swiss-based Quad9 Foundation, whose mission is to provide a safer and more robust Internet for everyone.

670M+

Average Daily Blocks

230+

Resolver Clusters in over 110 countries

25+

Threat Intelligence Providers

Learn how to set up Quad9 on your devices

Privacy

How Quad9 protects your privacy

When your devices use Quad9 normally, no data containing your IP address is ever logged in any Quad9 system. Connections can employ encryption if your system supports it, and the entire Quad9 platform has been designed to be GDPR-compliant from the first public announcement in 2017.

Read more about Quad9’s privacy

Why Quad9 is dedicated to data privacy

Every transaction on the Internet starts with a DNS event. This name lookup reveals critically sensitive data about the person triggering that transaction. The nature of those name lookups has created a strong and dangerous motivation for commercialization of personal data from DNS recursive resolver services. Quad9 is the only large DNS resolver with a founding charter that includes privacy as a primary goal, and the Quad9 team is devoted to the concept of keeping personal data under the control of the end user.

End users have made it clear to industry that privacy should be a central focus for Internet platforms and infrastructure. This demand-side dynamic cannot be fulfilled with the promises of encryption technology alone, however. Quad9 understands the need to compliment complement their its secure and privacy-preserving protocols with policies and practices that protect users too. Based in Europe, Quad9’s DNS service now leverages a strong regulatory environment in the public interest.

Mallory Knodel

Chief Technology Officer,
Center for Democracy and Technology

Privacy matters, but is increasingly endangered. We’re happy to have another major internet infrastructure provider joining the European tech ecosystem, illustrating again that privacy is the future for European tech.

Dr. Andy Yen

Founder and CEO,
ProtonMail

Quad9’s organizational move to Switzerland is important for the free and open internet because it provides much-needed geographic and legal diversity in the open DNS resolver space. It also shows that Quad9 is actively seeking to work within the legislative framework that best serves the privacy of its users.

I support the Quad9 open resolver because it puts the end user first and helps build a secure and private internet without collecting – and therefore without the possibility of commercializing – users’ personal information. I believe Quad9’s philosophy of openness and transparency in handling users’ data resonates strongly with the core beliefs of our community.

Christian Kaufmann

Chairman,
RIPE

As the CEO of Alta Associates, the leading executive search firm in Cybersecurity, and Founder of the Executive Women’s Forum on Information Security, Risk Management & Privacy, I have a unique understanding of the challenges cybersecurity leaders face. Quad9 provides these leaders with an actionable way to protect their systems against threats while preserving their end-users privacy.

Joyce Brocaglia

CEO Alta Associates,
Founder Executive Women's Forum

This step by Quad9 is a good example of what may need to be done to increase confidence in the Internet globally. It also demonstrates the importance of all stakeholders playing their respective roles - technical community providing a robust technical solution, private sector enabling and supporting the model, and robust government regulation providing a trust-guarantee. A welcome addition to the Internet infrastructure

Tomas Lamanauskas

Head of Corporate Strategy Division,
International Telecommunication Union ITU

Digital leaders in Switzerland are reviewing IT strategies to ensure best practices across their digital transformation journeys. Companies like Quad9 are providing key solutions in this area, supporting everyday web traffic, fundamental to the internet puzzle. We are delighted to host this important service at Equinix.

Roger Semprini

Managing Director,
Equinix Switzerland

With its transparent privacy policy, board of directors of multiple stakeholders, and strong presence on six continents, Quad9 sets an example for public domain name services for the benefit of the common good. I am proud to be on the governing board of the Quad9 project during its important transition to European governance. This marks an important milestone for global privacy, with the protection of Swiss law and oversight now available to DNS users around the world.

image

Benno Overeinder

Director,
NLnet Labs

I’m really impressed by the privacy architecture of Quad9. In addition to providing great security as a DNS resolver, Quad9 doesn’t collect or retain personal data. Now, it is relocating to Switzerland, where it will become subject to the rigors of Swiss data protection law, which is similar to GDPR. In addition, it obtained findings of law from the Swiss government whereby it won’t be required to retain personal information, nor will it be subject to requests from law enforcement or national security

image

Omer Tene

Vice President and Chief Knowledge Officer,
International Association of Privacy Professionals

As a European DNS vendor, we welcome Quad9’s decision to relocate to Switzerland, providing a much needed GDPR-guaranteed public resolver. This proves that strong privacy laws actually attract business.

image

Vittorio Bertola

Head of Policy & Innovation,
Open-Xchange

Quad9 provides an invaluable service keeping internet users secure. Their continued development as an international non-profit, domiciled in a place with strong privacy laws, will ensure that this mission continues to be successful.

image

Dr. Serge Droz

Member, Board of Directors,
Forum of Incident Response and Security Teams

The privacy and security of Internet users depend on the availability of private and secure services, critically including Domain Name System resolvers. Digitale Gesellschaft operates one such DNS resolver for Switzerland, and we welcome Quad9 and its established global reach to Switzerland.

image

Erik Schönenberger

Executive Officer,
Digitale Gesellschaft

Swiss regulators and leading companies have joined forces in the Swiss Internet Security Alliance, SISA, to make the internet a safe place. We are glad that there are nonprofit organizations like Quad9 that offer Internet users better protection against phishing and malware with a few simple steps, free of charge. Welcome to Switzerland, Quad9!

image

Daniel Nussbaumer

President,
Swiss Internet Security Alliance

Quad9’s move to Switzerland is a welcome improvement in the world of public resolvers. This change of domicile makes Quad9’s commitment to privacy clear: their policies are now bound by the strength of Swiss law. We welcome you to your new home in Europe, Quad9!

image

Ulrich Wisser

Senior DNS Expert,
The Swedish Internet Foundation

The National Cyber Security Centre (NCSC) of Switzerland supports the idea of conducting Quad9’s activities in a non-profit organisation (NPO) in Switzerland. As a neutral location, Switzerland is the premier site for such activities. Together, as a Public Private Partnership (PPP), we can make the internet safer and position Switzerland as a trustworthy location.

image

Florian Schütz

Federal Cybersecurity Delegate,
None

Security

How Quad9 blocks malware

Quad9 routes your DNS queries through a secure network of servers around the globe. The system uses threat intelligence from more than a dozen of the industry’s leading cybersecurity companies to give a real-time perspective on what websites are safe and what sites are known to include malware or other threats. If the system detects that the site you want to reach is known to be infected, you’ll automatically be blocked from entry – keeping your data and computer safe.

Why Quad9 provides security services

For the Internet to be an effective tool, users must trust their ability to use online services without fear of theft, fraud, or misuse of their devices by criminals. Public and private network operators need protection against malicious use of infrastructure resources and attacks against their users or customers. Quad9’s mission is to improve the security and stability of the Internet to allow everyone to be less vulnerable to risks and more effective in their daily online interactions.

Participate

How to use Quad9

Quad9 can be used simply by setting the DNS server settings for your device to the addresses given in one of our service profiles. No sign-up is required, no account data needs to be given to Quad9, and there is no contract. Quad9 is free to use and collects no personal data about you. You can configure your router or wifi access point to distribute these settings, which will extend protection to all the elements on your local network including IoT devices, many of which otherwise would not have any anti-malware defenses.

Why participate?

Quad9 is a not-for-profit organization, relying on grants and partnerships with commercial and non-commercial sources and from individuals. Your use of Quad9 may prevent a ransomware attack, prevent your bank account from being compromised, or protect your laptop from being used as part of an illicit criminal attack on others. All of these potential protections and many millions of other interventions have a direct savings result for you, your business or organization, and the companies you rely on such as banks and e-commerce firms. We hope that this understanding may inspire you to donate to Quad9, as an individual or with a corporate sponsorship.

Donate