When RAG retrieval disappoints, the advice AI engineers hear today is almost always “add a reranker”. Ask why a reranker works, and the answer usually stays at the architecture level: it is a cross-encoder, it applies attention over the query and the passage together, it is fine-tuned on relevance labels. All of that is true, and none of it says what the model actually learned. Push one level down, to terms a business partner could check, and the explanation usually stops.That gap matters. A team that cannot say in plain terms what the reranker does cannot defend the choice to use one, and cannot spot the cases where a keyword lookup would beat it for a fraction of the cost.This article gives the honest answer, the one you can hand to your business partner without waving hands. The reranker is not smarter than the embeddings step below it. It runs the same mechanism (statistical token association from training data), just conditioned differently (on the query-passage pair rather than each text independently). Once you see that, the “when to use a reranker” question stops being “add it because the tutorial did” and becomes “add it only when this specific tradeoff is worth paying for”.🧭 New to the series? Start with the map: Prompt, Context, Loop sets out the three engineering layers every RAG system is built on, the prompt (the call itself), the context (what fills the model’s window), the loop (when the next call fires and when it stops), and walks the whole series through that lens, article by article. It is the shortest way to see what is covered and where this one sits.This article sits in Part I, alongside the embeddings triptych (2A / 2B / 2C). – Image by author📓 Try the reranker on your own PDF at doc-intel/notebooks-vol1. The companion notebook loads a cross-encoder, applies it to a keyword-filtered top-K, and shows both the score and the tokens driving it. Change the query, watch which keywords carry the ranking.1. What data scientists say, and why it isn’t enoughAsk three data scientists what a reranker does and you get three answers, roughly:“It’s a cross-encoder. It scores the query-passage pair jointly and gives a relevance score.” Technically true, but the words cross-encoder and relevance are hiding what the model actually learned.“It applies attention over both texts, so it sees the interaction between them.” True at the architecture level, but architecture does not tell you what the model is doing with that attention.“It’s trained on relevance labels, so it learns which passages answer which questions.” Very close, but “learns which passages answer” is the wrong verb. The model does not learn to answer. It learns which tokens co-occurred.None of the three is wrong. All three are incomplete in a way that matters when you have to decide whether to keep the reranker in your pipeline, whether to fine-tune it on your corpus, or whether to replace it with something cheaper.The rest of this article walks that answer down to the mechanism, then names three consequences that change how you architect enterprise RAG.2. What actually happens inside a rerankerThe reranker is a specific kind of transformer, trained on a specific kind of data, that produces a specific kind of number. Each of those three pieces matters.2.1 The architecture: cross-encoder, not bi-encoderAn embedder (bi-encoder) reads the query alone, produces one vector. Reads a passage alone, produces one vector. Compares the two vectors by cosine. Each text is embedded independently, and the model never sees them together during scoring.A reranker (cross-encoder) reads the query and the passage together, as one concatenated input: [CLS] query [SEP] passage [SEP]. It runs BERT-style attention over the joint input, where every token can attend to every other token. It outputs a single relevance score.That “reads them together” is the whole architectural difference. Bi-encoder: two vectors, one comparison operation. Cross-encoder: one forward pass, one score. The joint attention is why the reranker feels smarter, and why it is 30 to 100 times slower per query.2.2 The training data: MS MARCO and its cousinsWhere does the reranker learn its scoring? From query-passage relevance pairs labeled by humans. The canonical dataset is MS MARCO (Bajaj et al. 2016, one million real Bing search queries with human-graded passage relevance). Others: Natural Questions (Google search + Wikipedia paragraphs), BEIR (a benchmark aggregator), TREC.Every training example is a triple: (query, passage, relevance_label). The model sees millions of these, and its weights adjust so that pairs labeled relevant get higher scores than pairs labeled not relevant.That is the sole learning signal. The model is never shown a question and asked to compose an answer; it is shown pairs, and it optimizes for a score that separates relevant pairs from non-relevant ones.Which raises the honest question: what pattern actually separates them in the training data?2.3 What the model really learns: keyword co-occurrence at the pair levelHere is the level down that rarely gets explained.The model looks at millions of (query, passage, relevance) triples and asks: what patterns in the joint token stream predict the relevance label? The dominant pattern is not “answering”. It is which query tokens tend to co-occur with which passage tokens in high-relevance pairs.Concretely, in MS MARCO the query “how to cancel my subscription” is labeled relevant against passages containing cancel, subscription, unsubscribe, terminate, end your membership. Millions of examples reinforce that when the query contains cancel, passages containing terminate or unsubscribe tend to be labeled relevant. The reranker’s weights absorb that association.So the “smart” reranker is doing keyword linking, at the query-passage pair level. It is a learned association table between query token neighborhoods and passage token neighborhoods, dressed up as a neural network score.The embedder does the same thing, but at each text independently. The reranker does it conditioned on the pair. Same mechanism, different conditioning.Second-order signals the reranker also picks up: positional patterns (a term appearing early in the passage often correlates with relevance), syntactic structure (subject-verb-object relations that link query tokens to passage tokens), the presence of definitional phrasing (“X is Y”). Those help, but they are second-order; the dominant signal is keyword co-occurrence.Why this frame matters: once you see the mechanism, the “will it work on my corpus?” question has a clear answer. If your corpus vocabulary and query vocabulary look like MS MARCO (general English, common web topics), the trained associations transfer, and the reranker feels magical. If your corpus vocabulary is specialized (insurance contracts, medical records, regulatory filings), the trained associations do not cover your domain, and the reranker inherits the same out-of-vocabulary failures as the embedder below it. No amount of “but it’s a cross-encoder” fixes that.3. The mechanism, shown: where the reranker wins, where it hits a wallSection 2 made a claim: the reranker is a learned association table between question-language and answer-language. That claim is testable. Take a handful of candidates, score them with three embedders (MiniLM, ada-002, text-embedding-3-large) and three cross-encoders (bge-base, bge-large, ms-marco-MiniLM), and read each row.3.1 Where it wins: the answer that does not repeat the questionAsk “What is the maximum coverage amount?” against three passages: the answer (“Cover is capped at 50,000 euros per year”), an echo that repeats the question’s words without answering (“The maximum coverage amount can be found in the benefits schedule”), and a distractor.Every embedder ranks the echo first; both bge rerankers flip the answer to the top. – Image by authorEvery embedder puts the echo first. It shares maximum, coverage, amount with the question, so its vector sits close. The answer shares almost nothing lexically, so it lands second or third. The two bge rerankers flip it: they read the question and the answer together, recognize that a “capped at X per year” passage answers a “maximum coverage amount” question, and lift it to #1. This is the reranker doing its one real job, bridging the question’s words to the answer’s words.It is not a one-off. The same flip reproduces on plain factoids:Same shape, general-knowledge version. bge lifts the answer over the echo, ms-marco keeps the echo on top. – Image by authorAcross a dozen queries of this shape (who wrote a play, the boiling point of water, the speed of light, the first president, plus the enterprise trio of deductible, notice period, coverage) the two bge rerankers rescue the answer to #1 where every embedder ranked an echo above it. The win is real and repeatable, on exactly one shape: a short factual answer that does not repeat the question, sitting behind an echo that does.Two honest caveats sit in the same two figures. First, not every reranker does it: ms-marco-MiniLM keeps the echo on top in both cases, the same lexical bias an embedder has. Second, when a strong embedder already answers the question (text-embedding-3-large gets several of these on its own), the reranker adds nothing over just using a better embedder.3.2 Where it hits a wall: your private vocabularyNow the case that decides the enterprise question. Ask “what’s the rule on contractor overtime?” where the answer uses the company’s own term, “non-employee labor compensated beyond 40h/week”, and never the word contractor.The answer never says “contractor”, it says “non-employee labor”. Every model, embedder and reranker alike, ranks it last. – Image by authorEvery column, embedder and reranker, ranks the answer last. The surface match (“Contractors are paid on a per-project basis”) wins. The reranker never saw contractor map to non-employee labor in MS MARCO, so its association table has no entry for it. The cross-attention it runs is real, but it can only fire on associations it learned, and this one it never learned.3.3 To clear that wall, you must already know the answerThe fix the literature offers is fine-tuning: feed the reranker labeled (question, passage, relevant) triples from your own domain until it learns that contractor maps to non-employee labor. But look at what labeling one of those triples requires. Someone who knows the domain has to point at the right passage and say this one answers the question. To point at it, they had to recognize that “non-employee labor beyond 40h/week” is what the answer looks like. That recognition is the answer keywords.So the training label and the dictionary entry carry the same information. For a “maximum coverage amount” question, labeling the answer means knowing the answer contains capped at, up to, a currency, per year. Writing the expert dictionary means typing exactly that: {capped at, up to, maximum, €, per year}. For the contractor case, labeling the pairs means knowing that contractor equals non-employee labor in this company, and the dictionary entry is that one line.The difference is the cost and the shape. The reranker needs hundreds of labeled pairs to generalize the mapping statistically, a retraining run, and it stays a black box scoring 0.83. The dictionary needs one line, fires deterministically, and shows the exact keyword that matched under audit. If you already know the answer well enough to label the data, you already know the answer keywords, and writing them down is the cheaper, auditable path. The reranker’s statistical learning only pays when the mapping is too broad to enumerate, which is the open web, not a bounded enterprise domain.4. Why the answer matters in enterpriseThree consequences flow from the honest answer, and each of them changes an architecture decision you may have made without noticing.4.1 The audit trail is opaqueA relevance score of 0.83 from a reranker is not defensible under scrutiny. A regulator asking why was this passage returned? gets “the reranker gave it 0.83” as an answer. That is not an audit trail. It is a black box that produced a number.Contrast with a keyword filter: the retrieved passage contains force majeure and pandemic. That statement is inspectable, replayable, and defensible. If the retrieval was wrong, you can trace which keyword was missing from the dictionary and add it. If a reranker was wrong, you shrug at the score and move on, or you retrain the whole thing.For enterprise use cases where retrieval decisions have compliance or contractual consequences (insurance underwriting, legal discovery, medical records, regulatory reporting), opacity is not a small tradeoff; it is a disqualifier.4.2 The cost is realA cross-encoder is 30 to 100 times slower per query than a bi-encoder. If your bi-encoder scores 1000 candidates in 20 ms, the reranker scores the same 1000 in 600 ms to 2 seconds. In practice, you do not rerank 1000 candidates: you take the bi-encoder’s top-20 or top-50 and rerank only those, which puts the added latency back in the 15 to 100 ms range, depending on the depth and the model.That is fine at low query volume. At 100 queries per second sustained, the reranker cost is a real operational line item: more GPU capacity, longer p99 latencies, more infrastructure to keep warm. The value it adds has to justify that cost, and that only happens when its trained associations genuinely cover your vocabulary. On out-of-domain enterprise corpora, it often does not.4.3 The vocabulary gap will show upEvery failure mode catalogued for embeddings on out-of-domain enterprise vocabulary applies to the reranker too, because it was trained on the same distribution (general web search). Force majeure and act of God are equivalent in an insurance contract but land in different neighborhoods in the reranker’s learned associations, because it saw them in different training contexts. Rescission was rare in MS MARCO. ShieldPro Elite was not there at all.Fine-tuning the reranker on your domain corpus helps, but only up to a point. You need labeled query-passage pairs from your domain to fine-tune, which is exactly what enterprise teams rarely have. And even a fine-tuned reranker inherits the same underlying mechanism: it still learns token associations, just from your smaller domain corpus, and the number of examples you can label rarely matches the millions MS MARCO provides.5. What to do instead, and when to keep the rerankerGiven the mechanism and the enterprise consequences, the question becomes: what earns the reranker’s slot in your pipeline?The default in enterprise RAG (per the series’ recommendation): a curated keyword dictionary maintained by domain experts. The expert already knows that force majeure equals act of God in this contract, that rescission is the formal term for what the user called cancellation, that ShieldPro Elite is the top-tier homeowners plan. Encoding that once in a versioned YAML dictionary and running keyword-based retrieval on top gives you:Auditable retrieval (the matched keywords are inspectable)Low latency (no LLM in the hot path, no GPU cost)Durability across model releases (the dictionary outlives every reranker version)Explainability to the business (they can read the dictionary)The reranker earns its slot in four specific cases. The first three are runtime slots, the fourth is not.In-domain distribution. Your corpus vocabulary and query vocabulary genuinely look like MS MARCO (general web, common English, high-frequency topics). Consumer FAQs, public-service portals, e-commerce help. The reranker’s trained associations transfer. Use it.Semantic re-ranking of a keyword-filtered top-K. After the keyword dictionary filters the corpus down to 20 candidates, the reranker can order them by contextual relevance. This is the same role Article 2C section 5.3 assigns to bi-encoder embeddings, and a cross-encoder does it more accurately at the cost of extra latency. Worth it when the top-K is small and the ordering matters.Compliance scenarios where the reranker’s score itself is the audit artefact. If your compliance framework requires “the model scored this passage above threshold X”, the score is the artefact, and the reranker fits the requirement.Offline, to discover what belongs in the dictionary. Run the reranker over a sample of real questions and read what it pulls up. Where it surfaces a mapping the dictionary does not have yet, you have a candidate alias. An expert confirms it or throws it out, and only the confirmed line ships. The model does the searching, the expert does the deciding, and what reaches production is the validated line, never the score. Article 2C gives embeddings the same treatment, and Article 16D runs this loop continuously at corpus scale, a failed search proposing the alias and an expert confirming it.The fourth case is the one that reframes the other three. Both paths do the same job, and the diagram below puts them side by side.The same table twice: learned on someone else’s corpus, or written by people who know the words. – Image by authorOutside those four cases, the reranker mostly adds cost: impressive in a demo, expensive in production, opaque under audit, and unable to compensate for the trained associations it does not have.One equivalence sits underneath all of it, and it is worth stating in a single line. A reranker is a keyword-association table that someone else trained on someone else’s corpus. Writing your own dictionary is the same job, done by the people who actually know the vocabulary, at a fraction of the cost and in a form an auditor can read. That equivalence stays invisible as long as the model is treated as magic. Open the box, as Section 2.3 did, and the choice makes itself: use the model to find candidate links, use the expert to validate them, and let the validated table be what production runs on.6. Sources and further readingThe reranker literature is dense and largely optimistic. Reading it against the article’s frame (“cross-encoders learn keyword association at the pair level, not comprehension”) is more useful than reading it as an unqualified endorsement.Same direction as the article:Nogueira & Cho, Passage Re-ranking with BERT, 2019 (arXiv:1901.04085). The paper that introduced cross-encoder reranking with BERT and set the pattern most current rerankers follow. Reads honestly about what the model learns.Khattab & Zaharia, ColBERT, SIGIR 2020 (arXiv:2004.12832). Late-interaction retrieval. Explicitly designed to preserve token-level signal that both embedders and cross-encoders lose, which is the strongest architectural signal that the token-level pattern is what actually matters.Different angle, different context:Bajaj et al., MS MARCO, 2016 (arXiv:1611.09268). The training data that shapes what almost every commercial reranker actually knows. Worth skimming to see the query and passage distribution the reranker’s associations come from.Muennighoff et al., MTEB: Massive Text Embedding Benchmark, EACL 2023 (arXiv:2210.07316). Includes reranker leaderboards. The leaderboard is measured on in-distribution benchmarks, which is exactly the case where the reranker looks good. It says less about what happens on your out-of-domain enterprise corpus.

Now that we have coding agents that are extremely proficient at writing code, I experience a lot of smaller tasks coming up that have to be fixed. This is a general observation I’ve made from working with startups and applications: because the effort to write code has gone down so much, the threshold for providing product feedback has lowered, and requests for quick fixes have vastly increased.Of course, when doing this, you can spin up one Claude Code or Codex session per task. However, you start having problems once you receive 50 to 100 tasks per day, where you obviously don’t want to spin up that many separate coding sessions. At the same time, you don’t necessarily want to put everything in one session, since you can run into context-length limits and the model may struggle to orchestrate all the tasks effectively.This is an issue I started experiencing myself a lot, and I just started developing a philosophy and methodology to solve hundreds of smaller tasks in an effective manner.In this article, I’ll take you through the methodology that I use on a daily basis to work more effectively with my Claude Code sessions to solve a lot of coding tasks.This infographic highlights the main contents of this article and discusses how to effectively solve a large number of smaller coding tasks using coding agents such as Claude Code or OpenAI Codex, Image by ChatGPT.Why optimize how to solve smaller tasksAs always, I’ll take you through why you should care about optimizing how to solve smaller tasks. You might think that coding agents have become so efficient that simple quick fixes are something you can just throw at a coding agent and it immediately solves everything for you, and you don’t really have to think about it. To some extent, this is true. I mean, you can, in many cases, just fire off tasks, for example, a Linear task to a coding agent, and it will, in many cases, be able to solve it itself and drive it to dev and production with very little human interaction.However, the problem arises when you start having a lot of these smaller tasks coming in, which can happen because of:BugsSmaller feature requestsDesign updatesand many other cases.Thus, you need a strong methodology for working through all of these tasks, verifying they’re solved in a correct manner, and marking them done. Some smaller tasks can be done fully autonomously by coding agents. However, I also found that a lot of similar-looking tasks are a bit ambiguous. If you simply ask a coding agent to fix such a task without any more input, you might find that the coding agent did not actually solve the problem, or in many cases, even worse, that the coding agent did something it wasn’t supposed to do and changed a part of your application that you didn’t intend to change.Due to the challenges I mentioned here:Solving a lot of smaller tasksAmbiguities in smaller tasksYou need a good methodology for completing all these tasks, which is what I’ll cover in the following sections.My coding methodologyNow I’ll cover my coding methodology to more effectively solve a lot of these tasks. I’ll take you through my high-level pipeline and the philosophy and mindset that I have for solving these tasks.The pipeline looks as follows:The issue is posted, typically through SlackAn agent picks up the task and creates a Linear issue for itI have a Claude Code session to deal with all of these tasks, typically for a specific time period, for one specific day in my case.I triage the tasks through my Claude Code session. If it’s a simple quick fix, I use the Claude Code session to fix it. If it’s a bigger issue, I have the agent in the session create a hand-off up front and work on a completely separate thread to solve the issue because it needs more human interaction.I make Claude Code create an HTML report of all the smaller issues that we want to work through. If it has any questions for me, I need to clarify them and give it guidelines on how to complete the tasks.Claude Code spins up a sub-agent for each smaller task and drives it to devOnce it’s in dev, I receive another HTML report on how to test the feature, and I check if it was implemented correctly. If this is the case, the task is marked done. If not, I iterate until it’s implemented correctlyIssue triagingFirst, now I want to talk about the first five steps in my pipeline, which can be summarized into issue triaging. So, basically, you should, of course, have a common place where all the feedback is posted. Slack is a great channel to do that, but you can also use any other messaging app, of course. I then have an automatic bot that creates Linear issues or tickets. I use Linear because it’s a good and clean interface for interacting with coding agents. They have automatic updates on task progress, and you can easily post updates to any task and keep a good overview of the projects you’re working on.Once a Linear ticket or issue has been created, they are now accessible to my coding agent. I typically start one Claude Code session per day for smaller tasks. So I have an August 15th session, an August 16th session, and so on. But of course, you can adapt this to any time period that you prefer.Once I’m in the Claude Code session, I ask it to read through the Linear tickets from that day or Slack and find all the tasks and map them out to an HTML report. It should then look into each task and present me with the report, with details about the task, which I read through. I give Claude Code any input that it should have to complete a certain task; for example, I try to clarify any design decisions or how something should be implemented. Also, if it’s a bigger task, which sometimes comes in, then I ask Claude to make a handoff, because I wanna do bigger tasks in a separate thread.The reason I want to do bigger tasks in a separate thread is that they require more human input, and when they require this, it gets very messy if I have it in the main Claude Code sessions where I do all of the smaller tasks. It’s better to have it in a separate session where all the questions the coding agent has for me are centralized in one location, and I can interact with the coding agent there. I simply find that it’s a more efficient way to complete bigger tasks.After this, I’m done with the issue triaging.Effectively solving the tasksNow let’s talk about point number 6, which is about how I effectively solve all of these smaller tasks. The simple way I do it is that I ask Claude Code explicitly to spin up sub-agents to complete each task individually. When you do this, it’s very important that you instruct Claude Code to spin up sub-agents in separate worktrees so that the sub-agents don’t interfere with each other. And this is a great way to do it because Claude spins up one sub-agent per task that you’re working on, and it’s very easy to keep an overview of all the sub-agents. You can basically see them in the menu in the CLI. If you want to dive into one specific sub-agent, which admittedly is something I do quite rarely, you can also just click on it and see what’s going on there.Then I basically let Claude Code continue working on each subtask, asking it, of course, to implement it correctly, verify its own work, run a code review, and drive it to dev immediately. In most cases, I ask Claude Code to simply drive it directly to dev. Though, if it’s a task such as a design task where I know agents can make mistakes, I might have the sub-agent spin up a localhost server and verify the work there before I ask the model to drive it to dev.Verifying the workThe last step is, of course, to verify the work. I find that in most cases, it’s worth just spending 30 seconds to 1 minute verifying the work for one task. In most cases, Claude has implemented it correctly, but I do find that it’s very hard to know which tasks are likely to be implemented incorrectly, and I thus do spend the time verifying the work manually.However, I have optimized the way I verify the work. To verify the work, I basically ask Claude Code to present me with an HTML report with each task that it implemented and exactly how I can test the task. This should include the original Slack message or Linear issue quoted verbatim. It should include a link to the exact page where I can test the issue. For example, if you wanted to fix the design in the chatbot functionality, the AI should give you the link to a specific chatbot thread, so you can check it out there and you don’t have to navigate the product yourself.I can basically then just go through the checklist that the agent has provided me in the HTML report and verify the work very easily. If I deem the work to be implemented correctly, I say that the task is verified and it can be set to done because it’s already in dev most of the time. If it’s not, I give the agent feedback on what it did incorrectly, ask it to implement it, and come back to me with a new HTML report once it’s fixed so I can test it again.ConclusionThis is basically my problem-solving pipeline for coding efficiently with Claude Code. I think all the steps that are covered in this article are very important, as they each contribute to the next step being completed efficiently. For example, issue triaging is a very important prerequisite for a single Claude Code session to be able to spin up sub-agents to complete all of the smaller issues. And then having the sub-agents is, of course, very important, and having an effective way of verifying the work with HTML reports is critical to keep testing speed up with implementation speed. I hope you learned something from this article and try implementing some of this problem-solving pipeline into your own programming workflows, as I do believe this can be a very effective way of increasing speed when developing products.👋 Get in Touch👉 My free eBook and Webinar:🚀 10x Your Engineering with LLMs (Free 3-Day Email Course)📚 Get my free Vision Language Models ebook💻 My webinar on Vision Language Models👉 Find me on socials:💌 Substack🔗 LinkedIn🐦 X / Twitter

When my oldest child was born, I immediately set up Gmail and Twitter accounts in her name. I broadly announced her birth online and proceeded to plaster her photo across all sorts of platforms. In short, I began creating her digital footprint long before she could stand on her own two feet.  Fast-forward a couple of years to when my second kid came, and I had essentially the opposite reaction. I wanted to make sure I preserved her privacy. I didn’t want her birthday to be a matter of public record or her face to feed the algorithms. In time, I would go back and scrub much of the early footprint I had created for my first child as well.  What happened? I watched the promise of the early internet give way to the reality of its potential for abuse. I myself was already fully in the throes of smartphone and social media obsession. My wife, a pediatric nurse, grew increasingly alarmed at the number of children admitted to her hospital struggling with the effects of things like body dysmorphia or cyberbullying as a result of interactions on social media. We became those parents. The ones whose kids carry flip phones and aren’t on TikTok.  We are not alone in this. A surprising—maybe troubling—number of people I know who work at big tech companies also keep their kids at arm’s distance from technology. They lock down their phones, if they have phones at all, and keep them off social media. Hell, even Mark Zuckerberg doesn’t publicly post his children’s faces on Facebook or Instagram.  
If the desire to limit kids’ use of technology was once a subcurrent, it has become a raging flood. Jonathan Haidt’s best-selling 2024 book The Anxious Generation helped propel the issue into the mainstream (despite criticisms of his conclusions from some developmental psychologists). Last year, Australia became the first country to enact a social media ban for children under 16. Other nations, from Austria to Indonesia, have followed suit, announcing similar bans. The US Supreme Court recently upheld an age verification law in Texas, which acts as a de facto ban, and several states have flirted with their own measures. School districts all over the country are banning educational devices like iPads and Chromebooks in favor of actual books. Kids themselves seem to be embracing this tech skepticism too: The hottest gadget among the Gen Alpha set is a vintage Sony Walkman. We have to prepare our children to live in the actual world we have actually created, not the one we wish we had. Yet there is no hiding from technology. It permeates nearly everything, everywhere. And so we have to prepare our children to live in the actual world we have actually created, not the one we wish we had. How can we help kids survive and thrive in what we have wrought? 
It’s a question that feels all the more urgent in the era of AI. To help answer it, we brought in the editors of Anyway—an utterly fantastic magazine for teens and tweens that is so good in large part because it meets them where they are. (If there is a teen in your life, I highly recommend it.) They helped us with the stories you’ll see in this issue, and they asked kids to share in their own words how they are feeling about AI and what’s to come. What those young people told Anyway was complex, fascinating, and, to an incredible extent, thoughtful and sophisticated.  Meanwhile, I’ve loosened the digital tether—just a bit. I still don’t post many photos of my kids online, and I remain abundantly concerned about the perils of social media and AI.  But when my older daughter started high school, we retired the flip phone in favor of an iPhone. And my younger one now sports an Apple Watch. These devices have opened up the world to them in all sorts of ways. They help forge new friendships, building relationships that move seamlessly between digital and physical spaces. They allow my kids to roam free—or at least more freely—beyond the known spaces of our neighborhood and across the city.  Along the way, they’re learning and testing boundaries, just the way they’re supposed to. I guess you could say I am too. 

Puzzles and games have been central to AI development since the very beginning. Just as we humans like to test our smarts with crosswords or logic puzzles, developers can test how far models have advanced with a gaming gauntlet. The term “machine learning” was popularized in a 1959 article by the IBM computer scientist Arthur Samuel about an algorithm that learned to play checkers. Chess and the Chinese board game Go are famous AI test beds too.  Judged purely on its puzzling skills, AI is improving a lot—and quickly. In late 2024, a team of scientists from Columbia University showed that even the best models could figure out only 18% of the infamous New York Times Connections puzzles; by early 2025, some models could solve them near perfectly every time.  But puzzles do more than just highlight the inexorable advance of AI capabilities. Seeing where models succeed and fail—and where we humans still beat them—can provide a useful window into the technology’s strengths and weaknesses. Despite advances, today’s models still fumble: Subtle changes in classic riddles often trip them up, and visual puzzles are a particular weak spot.  Here you’ll have the chance to test your wits on puzzles that have stumped models at one time or another. Some might be as tricky for you as they were for the AI; others are so simple that they’ll have you doubting whether AI is really intelligent at all. Each one highlights at least one way in which machine and human cognition differ. If you ace the test, you’ll have proved that you can out-puzzle an AI—at least for now.  Spatial Reasoning Let’s start with a domain where humans have a huge advantage: spatial reasoning. If you’ve ever taken an IQ test, you may have done a mental rotation problem. These puzzles ask you to determine whether different images represent the same objects from different angles. Though today’s language models typically have the ability to analyze visual inputs, they still fail abysmally at these puzzles. For all the talk of how world models can help AI understand physical environments, LLMs still don’t seem to be able to manipulate 3D objects the way spatial thinkers like architects and mechanical engineers can. Mental Rotation Instructions: Choose the answer that shows the object in the prompt, but from a different angle. In each case, there’s only one correct answer!

.cst-large,
.cst-default {
width: 100%;
}

@media (max-width: 767px) {
.cst-block {
overflow-x: hidden;
}
}

@media (min-width: 630px) {
.cst-large {
margin-left: -25%;
width: 150%;
}

@media (min-width: 960px) {
.cst-large {
margin-left: -16.666666666666664%;
width: 140.26%;
}
}

@media (min-width: 1312px) {
.cst-large {
width: 145.13%;
}
}
} Memory & Adaptability Frontier LLMs have extraordinary memories; they were exposed to a monstrous volume of facts during training and can recite many of them faithfully. That’s an asset for outcompeting humans at trivia, but it can also be a liability. When a puzzle closely resembles one a model saw during training, the model may whiz by key differences and respond with what it memorized.  This held true in a 2024 study in which researchers from Google and the University of Illinois Urbana-Champaign trained and tested models on slight variations of a classic type of puzzle called Knights and Knaves. In these problems, some characters always tell the truth and others always lie, and you have to figure out who’s who. The same principle may be at work in a test called SimpleBench. These questions resemble more complicated problems that models likely encountered in training. Humans spot the trick, but even top-tier models trip.
Knights and Knaves Instructions: The only thing you need to know to solve these puzzles is that knights always tell the truth and knaves always lie. Determine who’s what on the basis of what each character says.
.cst-large,
.cst-default {
width: 100%;
}

@media (max-width: 767px) {
.cst-block {
overflow-x: hidden;
}
}

@media (min-width: 630px) {
.cst-large {
margin-left: -25%;
width: 150%;
}

@media (min-width: 960px) {
.cst-large {
margin-left: -16.666666666666664%;
width: 140.26%;
}
}

@media (min-width: 1312px) {
.cst-large {
width: 145.13%;
}
}
}

1

You have met a group of two islanders.
Their names are Edward and Wallace.

Wallace says:
Edward tells the truth.

Edward says:
Wallace and I are the same type.

2

You have met a group of three islanders.
Their names are Joseph, Francine, and Alice.

Francine says:
Joseph is a knave.

Francine says:
Alice tells the truth.

Alice says:
Joseph is not my type.

3

You have met a group of three islanders.
Their names are Robert, Vincent, and Michelle.

Michelle says:
Robert always lies.

Vincent says:
Michelle is truthful.

Robert says:
Vincent is untruthful.

Robert says:
Vincent is not my type.

SimpleBench Instructions: Read these SimpleBench problems carefully, and you should be able to figure out the answers in no time.
.cst-large,
.cst-default {
width: 100%;
}

@media (max-width: 767px) {
.cst-block {
overflow-x: hidden;
}
}

@media (min-width: 630px) {
.cst-large {
margin-left: -25%;
width: 150%;
}

@media (min-width: 960px) {
.cst-large {
margin-left: -16.666666666666664%;
width: 140.26%;
}
}

@media (min-width: 1312px) {
.cst-large {
width: 145.13%;
}
}
}

1

Beth places four
whole ice cubes in a
frying pan at the start of the
first minute, then five at the
start of the second minute
and some more at the start
of the third minute, but none
in the fourth minute. If the
average number of ice cubes
per minute placed in the pan
while it was frying a crispy
egg was five, how many
whole ice cubes can be
found in the pan at the end
of the third minute?

A
30

B
0

C
20

D
10

E
11

F
5

2

A juggler throws a
solid blue ball a meter
in the air and then a solid
purple ball (of the same size)
two meters in the air. She
then climbs to the top of a
tall ladder carefully, balancing a yellow balloon on her
head. Where is the purple
ball most likely now, in relation to the blue ball?

A
At the same height as the blue ball

B
At the same height as the yellow balloon

C
Inside the blue ball

D
Above the yellow balloon

E
Below the blue ball

F
Above the blue ball

Abstract & Visual Reasoning AI doesn’t just bungle visual problems in 3D—two dimensions can trip it up as well. That’s a major factor in how well models do on the most famous ­puzzle-based benchmark, ARC-AGI. These problems require you to infer abstract, general rules from a set of examples. Models do better on ARC puzzles when they receive each grid not as an image but as a string of numbers that encodes the color of each cell.  Research suggests that even when models answer ARC-AGI questions correctly, they often do so using byzantine and non-­generalizable rules, whereas humans draw on simple visual concepts. Despite these disadvantages, models have gotten quite good at ARC-AGI over the past year, but some puzzles—such as the one printed here—still stump them. ARC-AGI Instructions: Study the three pairs of grids shown below to figure out the rule that dictates how the ones on the left transform into the ones on the right. Then get out your markers or colored pencils and fill in the fourth grid using that rule. (The solution is the same no matter which way the grids are oriented.)
.cst-large,
.cst-default {
width: 100%;
}

@media (max-width: 767px) {
.cst-block {
overflow-x: hidden;
}
}

@media (min-width: 630px) {
.cst-large {
margin-left: -25%;
width: 150%;
}

@media (min-width: 960px) {
.cst-large {
margin-left: -16.666666666666664%;
width: 140.26%;
}
}

@media (min-width: 1312px) {
.cst-large {
width: 145.13%;
}
}
}

Now you try it

Your answer

Intuition It’s not just AI models that fall into traps. We humans have our own cognitive foibles, many of which AI does not share. Psychologists have designed problem suites that invert the SimpleBench phenomenon: For these questions, humans often give knee-jerk answers, whereas models will respond deliberatively. Some of the problems exploit errors in the ways that we intuitively do math; others are phrased so as to suggest obvious answers that fall apart if the question is read carefully. 
Lightning Round Instructions: Answer the questions below as quickly as you can.
.cst-large,
.cst-default {
width: 100%;
}

@media (max-width: 767px) {
.cst-block {
overflow-x: hidden;
}
}

@media (min-width: 630px) {
.cst-large {
margin-left: -25%;
width: 150%;
}

@media (min-width: 960px) {
.cst-large {
margin-left: -16.666666666666664%;
width: 140.26%;
}
}

@media (min-width: 1312px) {
.cst-large {
width: 145.13%;
}
}
}

1

In a cave, there is a colony of bats whose population doubles each day. Given that it takes 60 days for the entire cave to be filled with bats, how many days would it take for the cave to be half-filled with bats?

2

In what famous novel does Alice state “I’m late, I’m late, for a very important date”?

Increasing Complexity In some cases, whether an LLM can complete a puzzle is a matter of scale. One study from researchers at Apple found that LLMs can ace simple versions of the Tower of Hanoi problem, which involves moving a stack of disks one at a time without ever putting a larger disk atop a smaller one, and river-crossing puzzles, in which a group of people must traverse a river according to certain rules. But only up to a point: As the number of disks or people hits six and higher, the models began to falter. In another study, researchers at the University of Washington, Stanford University, and the Allen Institute for AI observed that LLMs struggle similarly with logic grid puzzles, which require deducing the attributes of a set of individuals from a list of clues. The Apple paper went viral, but commentators questioned whether the results reveal a unique limitation of LLM reasoning—or just that it’s normal to make errors as complexity piles up. The River Instructions: Using the scenario provided, plan the trips necessary to get everyone across the river. 

.cst-large,
.cst-default {
width: 100%;
}

@media (max-width: 767px) {
.cst-block {
overflow-x: hidden;
}
}

@media (min-width: 630px) {
.cst-large {
margin-left: -25%;
width: 150%;
}

@media (min-width: 960px) {
.cst-large {
margin-left: -16.666666666666664%;
width: 140.26%;
}
}

@media (min-width: 1312px) {
.cst-large {
width: 145.13%;
}
}
}

Three FBI agents and their three informants need to cross a river. They have a rowboat that can fit only two people, though it can be rowed by only one. Each agent will refuse to leave their informant on the same bank as other agents without them present—even if the informant never steps out of the boat and onto the bank. How can all six make it across?

Logic Grid Instructions: Using the list of clues, determine who lives in each house and what style of music each person enjoys. There is only one possible solution. You may find it helpful to fill out the grid below to keep track of your deductions.
.cst-large,
.cst-default {
width: 100%;
}

@media (max-width: 767px) {
.cst-block {
overflow-x: hidden;
}
}

@media (min-width: 630px) {
.cst-large {
margin-left: -25%;
width: 150%;
}

@media (min-width: 960px) {
.cst-large {
margin-left: -16.666666666666664%;
width: 140.26%;
}
}

@media (min-width: 1312px) {
.cst-large {
width: 145.13%;
}
}
}

The Neighborhood

There are 4 houses, numbered 1 to 4 from left to right, as seen from across the street.
Each house is occupied by a different person: Peter, Eric, Arnold, or Alice.
Each resident has a favorite type of music: jazz, rock, classical, or pop.

Alice is directly left of Peter.
The person who loves classical music is directly left of Peter.
Arnold loves jazz music.
The person who loves rock music is not in the second house.
The person who loves rock music is directly left of the person who loves pop music.

Click a cell to mark an X, click again for a check mark.

Grace Huckins is an AI reporter at MIT Technology Review. They have a PhD in neuroscience. Credits: Mental Rotation: CC BY 4.0. Stogiannidis, Ilias, Steven McDonagh, Sotirios A. Tsaftaris. Mind the Gap: Benchmarking Spatial Reasoning in Vision-Language Models (copyright 2025); illustrations by John MacNeill. Knights & knaves: Courtesy Dan MacKinnon. Simplebench: CC BY 4.0. SimpleBench Team. The Text Benchmark in which Unspecialized Human Performance Exceeds that of Current Frontier Models (copyright 2024). ARC-AGI: Courtesy ARC Prize Foundation. Lightning round: CC BY 4.0. Hagendorff, Thilo, Sarah Fabi, Michal Kosinski. Human-like intuitive behavior and reasoning biases emerged in large language models but disappeared in ChatGPT. Nat Comput Sci 3, 833–838 (copyright 2023). The river: Adapted from Propositiones ad Acuendos Juvenes, Alcuin of York (ca. 800 CE). Logic grid: Apache License 2.0. Lin, Bill Y., Ronan Le Bras, Kyle Richardson, et al. ZebraLogic: On the Scaling Limits of LLMs for Logical Reasoning (copyright 2025)

“Random Forest = many trees + averaging = better.” If you’ve read even one ensemble methods tutorial, this sentence is familiar to the point of nausea. And even following the most basic data science tutorials, anyone will understand that this is not wrong. What it is, on the other hand, is just dangerously incomplete, because if that were the whole story, the model would just be called “Bagged Trees,” and we would have stopped there. We would take bootstrap samples, train trees, average them, done. No need for the word “Random” in the name at all.But that’s not what happened. When Breiman designed Random Forest in 2001, he deliberately added a second layer of randomness: at every split, every tree only gets to see a random subset of the available features; not all of them but only a random slice.Why? If variance were the only problem, and bagging already reduces it through averaging, what does this extra, seemingly restrictive constraint add? Why deliberately make your trees “more blind”? Why hide existing information from your model that might prove to be significant?The answer hides in one word that practitioners throw around constantly but rarely unpack mathematically: correlation. Specifically, correlation between the predictions of the trees themselves. And once you see the math behind it, the whole design of Random Forest stops looking like a collection of arbitrary hyperparameters and starts looking like a single, elegant argument against a very specific enemy: correlated errors, which averaging alone can never fully eliminate, and which are exactly what stand between bagging and the algorithm’s real potential.That’s what this article is about: why bagging alone has a hard ceiling, what is this ceiling, and how feature subsampling is the mathematically necessary move to break through it.Bias-Variance, a Fast RefresherBefore we deep dive into the trees lets do a quick recap on how prediction error can be decomposed into three pieces:Error = Bias² + Variance + Irreducible NoiseBias: how wrong your model is on average, systematically. A model too simple for the underlying structure (say, a linear model on nonlinear data) will consistently miss the same way. This is underfitting.Variance: how much your model’s predictions swing if you retrain it on a different sample from the same distribution. A model too flexible (a fully grown decision tree) will fit the noise in whatever data it sees, and change dramatically with a slightly different training set. This is overfitting.A single, unconstrained decision tree sits at one extreme of this spectrum: low bias, high variance. It can represent almost any decision boundary (low bias), but it’s wildly sensitive to which exact rows ended up in its training set (high variance), resulting in a situation where if you swap a handful of data points you can get a structurally different tree.This is precisely why decision trees are the ideal raw material for bagging. Bagging’s whole mechanism of averaging many models, is a variance-reduction tool. It does almost nothing for bias. So it makes sense to pair it with a base learner that already has low bias and just needs its variance tamed, rather than, say, bagging a bunch of linear models where bias is the actual problem and averaging won’t touch it.Keep this pairing in mind — bagging attacks variance, not bias — because it’s the assumption the rest of the article stress-tests. The question we’re about to ask is: does bagging actually deliver on that promise fully, or only partially?The Mathematical Core: Discussing the variance computationSuppose you have n predictors and think of each one as a random variable X1,X2,…,XnX_1, X_2, …, X_nX1​,X2​,…,Xn​. In our case XiX_iXi​ is the prediction of tree iii at some fixed test point xxx. The randomness in XiX_iXi​ comes from the fact that tree iii is trained on a random bootstrap sample. If you re-ran the whole training procedure, you would get a slightly different tree, and therefore a slightly different prediction at xxx.Assume, for now, an idealized case:Each XiX_iXi​, has the same variance: Var(Xi)=σ2Var(X_i) = σ^2Var(Xi​)=σ2 for all iii.The XiX_iXi​ are mutually independent.We can form the ensemble prediction by averaging:Xˉ=1n∑i=1nXidisplaystylebar{X} = frac{1}{n}sum_{i=1}^{n}X_iXˉ=n1​i=1∑n​Xi​Deriving the variance of the averageThis is a direct application of how variance propagates through a sum of independent variables. For any two random variables:Var(aX+bY)=a2Var(X)+b2Var(Y)+2ab Cov(X,Y)Var(aX + bY) = a^2Var(X) + b^2Var(Y) + 2ab Cov(X,Y)Var(aX+bY)=a2Var(X)+b2Var(Y)+2ab Cov(X,Y)If XXX and YYY are independent, Covariance will be zero and the cross-term vanishes. Generalizing to nnn independent variables, each scaled by 1/n1/n1/n:Var(Xˉ)=Var(1n∑i=1nXi)=1n2∑i=1nVar(Xi)=σ2nVar(bar{X}) = Varleft( displaystyle frac{1}{n}sum_{i=1}^{n}X_i right) = displaystyle frac{1}{n^2}sum_{i=1}^{n}Var(X_i)= frac{σ^2}{n}Var(Xˉ)=Var(n1​i=1∑n​Xi​)=n21​i=1∑n​Var(Xi​)=nσ2​That’s it. That’s the whole derivation. No cross-terms survive because independence kills every covariance term in the expansion.What this says, physicallyAs n→∞nto inftyn→∞, Var(Xˉ)→0Var(bar{X}) to 0Var(Xˉ)→0. The ensemble’s variance can be driven arbitrarily close to zero, no floor, no limit just by adding more independent trees. This is the exact same logic as averaging nnn independent noisy measurements of a physical quantity: each measurement has its own instrument noise σσσ, but if the noise sources are truly independent (uncorrelated), the standard error of the mean shrinks as σ/ndisplaystyle σ/sqrt{n}σ/n​. Same square-root law, same origin: independence lets fluctuations cancel rather than accumulate.The key idea behind bagging is that, under the assumption of independent trees, averaging more and more trees continuously reduces the ensemble variance, eventually driving it arbitrarily close to zero.The catchAs said before this derivation rests on one assumption that is almost never actually true in Random Forests: independence. The trees are not independent. They’re trained on bootstrap samples drawn from the same underlying dataset, using the same features, often finding the same dominant splits near the top of the tree. That shared structure means Cov(Xi,Xj)≠0Cov(X_i , X_j) neq 0Cov(Xi​,Xj​)=0 and the moment covariance is nonzero, that cross-term we made vanish above comes roaring back into the formula.That’s exactly what the next section confronts head-on: what happens to Var(Xˉ)Var(bar{X})Var(Xˉ) when we drop the independence assumption and let the trees be correlated as they should be in any honest situation of every real Random Forest implementation.The Twist: Trees Are Never Truly IndependentLet’s drop the independence assumption and see what actually happens.Go back to the raw definition of the variance of a sum, without assuming independence this time:Var(Xˉ)=Var(1n∑i=1nXi)=1n2Var(∑i=1nXi)Var(bar{X}) = Varleft( displaystyle frac{1}{n}sum_{i=1}^{n}X_i right) = displaystyle frac{1}{n^2}Varleft( sum_{i=1}^{n}X_i right)Var(Xˉ)=Var(n1​i=1∑n​Xi​)=n21​Var(i=1∑n​Xi​)The variance of a sum, in full generality, expands into a double sum over all pairs (i,j)(i,j)(i,j):Var(∑i=1nXi)=∑i=1n∑j=1nCov(Xi,Xj)displaystyle Varleft( sum_{i=1}^{n}X_i right) = sum_{i=1}^{n}sum_{j=1}^{n}Cov(X_i, X_j)Var(i=1∑n​Xi​)=i=1∑n​j=1∑n​Cov(Xi​,Xj​)Split this double sum into two pieces: the diagonal terms where i=ji=ji=j, and the off-diagonal terms where i≠ji neq ji=j. When i=j,Cov(Xi,Xi)=Var(Xi)=σ2i=j, Cov(X_i,X_i)=Var(X_i)=σ^2i=j,Cov(Xi​,Xi​)=Var(Xi​)=σ2. There are nnn such terms.When i≠ji neq ji=j, each term is Cov(Xi,Xj)Cov(X_i,X_j)Cov(Xi​,Xj​), and there are n2−n=n(n−1)n^2-n=n(n-1)n2−n=n(n−1) such off-diagonal terms.Var(∑i=1nXi)=nσ2⏟diagonal+∑i≠jCov(Xi,Xj)⏟off−diagonaldisplaystyle Varleft( sum_{i=1}^{n}X_i right) = underbrace{nσ^2}_{diagonal} + underbrace{sum_{ineq j}^{}Cov(X_i, X_j)}_{off-diagonal}Var(i=1∑n​Xi​)=diagonalnσ2​​+off−diagonali=j∑​Cov(Xi​,Xj​)​​This is exactly where the earlier derivation cut a corner: independence forced every off-diagonal term to zero. We no longer get to assume that.Introducing ρNow define the (average) pairwise correlation between any two distinct trees:ρ=Corr(Xi,Xj)=Cov(Xi,Xj)σ2⇒Cov(Xi,Xj)=ρσ2ρ = Corr(X_i,X_j)= displaystylefrac{Cov(X_i,X_j)}{σ^2} Rightarrow \ Cov(X_i,X_j) = ρσ^2ρ=Corr(Xi​,Xj​)=σ2Cov(Xi​,Xj​)​⇒Cov(Xi​,Xj​)=ρσ2This is a simplifying assumption — a “mean-field” treatment, exactly like assuming a uniform pairwise interaction instead of tracking every individual pair separately. In reality, some tree pairs are more correlated than others (two trees that both got heavy weight on the same influential outlier row, say), but treating ρ as a single average captures the aggregate effect cleanly, and it’s a very standard move (this is essentially the same simplification Breiman himself used in the original Random Forest paper).With this substitution, the off-diagonal sum becomes:∑i≠jCov(Xi,Xj)=n(n−1)ρσ2displaystylesum_{ineq j}^{}Cov(X_i,X_j) = n(n-1)ρσ^2i=j∑​Cov(Xi​,Xj​)=n(n−1)ρσ2Putting it together we conclude that:Var(Xˉ)=1n2[nσ2+n(n−1)ρσ2]Var(bar{X})= frac{1}{n^2}left[ nσ^2 + n(n-1)ρσ^2 right]Var(Xˉ)=n21​[nσ2+n(n−1)ρσ2]and from the above point the math is pretty simple to derive the final expression for Var(Xˉ)Var(bar{X})Var(Xˉ):Var(Xˉ)=ρσ2+(1−ρ)σ2nVar(bar{X}) = ρσ^2 +displaystyle frac{(1-ρ)σ^2}{n}Var(Xˉ)=ρσ2+n(1−ρ)σ2​Sanity check: setting ρ=0ρ=0ρ=0 the first term vanishes entirely, and you’re left with σ2/nσ^2/nσ2/n which is exactly the independent case we ended up with before when we assumed tree independency. Good, the general formula correctly reduces to the special case. Lets now examine the limit; does it collapse correctly at the boundary?lim⁡n→∞[ρσ2+(1−ρ)σ2n]=ρσ2displaystylelim_{n to infty } left[ ρσ^2 +displaystyle frac{(1-ρ)σ^2}{n} right] = ρσ^2n→∞lim​[ρσ2+n(1−ρ)σ2​]=ρσ2The second term that carries all the benefit of averaging, and includes nnn vanishes exactly as before. But the first term ρσ2ρσ^2ρσ2, has no nnn in it at all. It was never going to vanish, no matter how large nnn gets.The consequenceYou could add as many trees as you want; tens or hundreds or even millions of them. Still the variance of your ensemble can never drop below ρσ2ρσ^2ρσ2. This is a hard floor, set entirely by how correlated your trees are, not by how many of them you have. Adding more trees only ever attacks the second term. It has zero leverage over the first.This is the mathematical fact that the entire design of Random Forest is built to confront. Next section asks where this ρρρ actually comes from in a real forest — but the diagnosis itself, the existence of this floor, doesn’t depend on any mechanism. It falls straight out of the algebra of correlated averaging, the same way it would for correlated noise in any measurement ensemble.Why ρ Exists, and How Random Forest Breaks ItWe’ve shown that if trees are correlated, averaging can’t save you as variance floors at ρσ2ρσ^2ρσ2. So where does that correlation actually come from?The causeEvery tree sees a different bootstrap sample, but the same underlying dataset. If one feature is a strong predictor (say, “price of a product”), it will win the best-split test at the root of nearly every tree, almost regardless of which rows got sampled because it’s structurally the strongest signal in the data and not an artifact of any particular sample. So trees end up with similar top-level structure, make similar errors in the same regions, and their predictions move together. Bootstrap sampling shuffles rows, but it doesn’t touch which feature dominates leading it to decorrelate noise and not signal.The Random Forest fixRandom Forest attacks this directly: at every single split, each tree is only allowed to consider a random subset of features (typically pdisplaystylesqrt{p}p​​ out of ppp). When the dominant feature isn’t in that subset, the tree is forced to split on something else. Different trees end up built around different features at different points, which breaks the shared structure and because of it, ρρρ drops.That is the whole idea. Bagging randomizes the training rows, which reduces the variance of each individual tree. Random Forest goes one step further by also randomizing the features at every split. This reduces the correlation ρρρ between tree predictions, and it is ρρρ rather than the number of trees nnn that limits how much the ensemble variance can be reducedThe Experiment — What We’re Actually TestingTheory is convincing, but nothing beats seeing the numbers move. So we set up a controlled comparison: build the exact scenario the theory describes, then measure ρ,σ2ρ, σ^2ρ,σ2, and Var(mean) directly, instead of just asserting them.The setup (code at the end of the article)We generate a synthetic population with 30 features, where two features are deliberately made dominant (they carry most of the true predictive signal) while the rest range from weakly informative to pure noise. This mirrors a realistic dataset: a few strong drivers, a handful of secondary ones, and a lot of clutter. It’s exactly the kind of structure that should push plain bagged trees toward high correlation, since every tree has every incentive to split on the same dominant features first.The key methodological choiceThis is where the earlier discussion about conditional vs. unconditional correlation actually matters for the experiment design, not just for the theory. If we trained many trees on bootstrap samples of one fixed training set, we’d be measuring conditional correlation and as we worked out, that correlation is exactly zero for independently-drawn bootstrap samples, no matter how much those samples overlap in content. That’s a mathematical fact, not a subtlety we can sidestep.Breiman’s ρρρ is unconditional: it treats the training set itself as a random draw from the population. So to measure it honestly, each independent “trial” of our experiment has to include a fresh training set, drawn anew from the population, not just fresh bootstrap indices from the same fixed set. All the trees within one trial share that one training-set draw — and that shared draw is the actual, real source of correlation between them.What we do, step by stepRun many independent trials (400 in our case). In each trial: draw a brand-new training set from the population, then train a large batch of trees on bootstrap resamples of it.Do this twice; once where every tree considers all 30 features at every split (plain bagging), and once where every tree only considers a random subset of features at every split (Random Forest, roughly 30≈5–6sqrt{30} ≈ 5–630​≈5–6 features per split). Everything else (the training set draws, the bootstrap sampling, the tree depth) is kept identical between the two, so the only thing that differs is that one design choice.At a fixed set of test points, record every tree’s prediction, in every trial.What we measure from that dataρ: how similarly two different trees behave, at the same test point, across independent trials. Basically, if we reran the whole experiment, would tree A and tree B tend to move together?σ²: how much a single tree’s prediction, at a fixed test point, varies across independent trials.Var(mean) vs. n: for a growing number of trees n, how much does the ensemble’s averaged prediction vary across independent trials?If the theory holds, the third quantity should trace out exactly ρσ2+(1−ρ)σ2/nρσ^2 + (1-ρ)σ^2/nρσ2+(1−ρ)σ2/n falling steeply at first, then flattening out at a floor set by ρρρ, and not by nnn.The ResultsHere’s what came out of running the experiment described above (400 independent trials, up to 120 trees per ensemble):Correlation and individual-tree variance-ρ (correlation)σ2σ^2σ2 (individual tree variance)floor = ρσ2ρσ^2ρσ2Plain bagging0.1369.891.34Random Forest0.04317.420.76Two things jump out immediately.First, ρ drops by roughly 3.2x once feature subsampling is introduced (0.136 → 0.043). Hiding the dominant features from most splits genuinely breaks the shared structure between trees. Rather than repeatedly building nearly identical trees around the same few informative variables, Random Forest encourages diverse tree structures. This diversity reduces the tendency of trees to make the same prediction errors, leading to a much lower inter-tree correlation.Second, and less obvious: Random Forest’s individual trees are actually worse. σ² is roughly double for RF (17.42 vs 9.89); a single Random Forest tree, on its own, is a noisier predictor than a single bagged tree. This makes sense: restricting each split to ~5–6 out of 30 features sometimes forces the tree away from the best available split, making that one tree more erratic. Feature subsampling isn’t a free lunch at the level of a single tree — it’s a trade: individual quality for reduced correlation.Third and more importantly, the asymptotic variance floor ρσ2ρσ^2ρσ2 decreases from 1.34 to 0.76. This demonstrates the key principle behind Random Forest: improving ensemble performance does not require stronger individual trees, but rather a collection of sufficiently accurate trees whose prediction errors are less correlated. Consequently, adding more trees yields a lower limiting ensemble variance than plain bagging.Ensemble variance vs. number of treesn (trees)Bagging: empiricalBagging: theoryRF: empiricalRF: theory19.899.8917.4217.4282.422.412.882.84181.851.821.681.68351.611.591.221.23701.491.460.960.991201.441.410.850.89Two patterns worth sitting with:The theory column and the empirical column track each other closely, all the way through. This isn’t guaranteed — the formula Var(Xˉ)=ρσ2+(1−ρ)σ2nVar(bar{X}) = ρσ^2 +displaystyle frac{(1-ρ)σ^2}{n}Var(Xˉ)=ρσ2+n(1−ρ)σ2​ is a mean-field approximation (a single averaged ρ standing in for many individual pairwise correlations), and it had every opportunity to diverge from what actually happened. It didn’t. The theoretical floor stopped being a symbolic derivation and became a number we can point to and say: this is where it plateaus, and we predicted it.The crossover At n=1, Random Forest starts behind as its lone tree is nearly twice as noisy as bagging’s lone tree (17.42 vs 9.89). But by around n=18, RF has already caught up and overtaken bagging (1.68 vs 1.85). By n=120, RF is sitting at roughly 59% of bagging’s variance (0.85 vs 1.44), despite starting from individually worse building blocks.That crossover is the entire article compressed into one sentence. Averaging alone can’t rescue plain bagging — no matter how many bagged trees you add, you’re stuck above ρσ2≈ρσ² ≈ρσ2≈ 1.34. Random Forest starts from a worse position per tree, but because it decorrelates the ensemble, it keeps improving well past the point where bagging has already flattened out ending up in a completely different neighborhood.All the above can be compressed in the following illustrated image generated by the code in the appendix.The Subtle Point: Worse Trees, Better ForestIt’s worth pausing on something that previous sections numbers already showed, because it’s the detail that surprises people who have used Random Forest for years without digging into why it works: a single Random Forest tree is a strictly worse predictor than a single bagged tree, and yet the Random Forest ensemble ends up strictly better.This isn’t a contradiction but the entire point, once you separate two things that are easy to conflate:Individual quality (how good is one tree, on its own): bagging wins here. σ² = 9.89 for bagging vs 17.42 for RF. Clearly, a bagged tree, seeing all 30 features at every split, simply makes better individual decisions.Ensemble quality (how good is the average of many trees): RF wins here, and not narrowly as at n=120, RF’s ensemble variance is 0.85 vs bagging’s 1.44, roughly 41% lower.The mechanism connecting these is entirely about ρρρ, not σ2σ^2σ2. Feature subsampling doesn’t make trees better — if anything, it makes each one a bit worse, since it’s occasionally forced away from the strongest available split. What it buys is independence between the mistakes different trees make. And because the ensemble variance formula weights ρρρ so heavily (recall: ρρρ survives untouched as n→∞nto inftyn→∞, while σ2σ^2σ2’s contribution shrinks toward zero), a small sacrifice in individual quality can purchase a much larger reduction in shared error.This is a genuinely counter-intuitive trade for anyone used to thinking “better base learner → better ensemble.” For Random Forest specifically, the opposite can hold: a slightly worse base learner, if it’s less correlated with its peers, produces a meaningfully better ensemble. It’s the same logic behind why a portfolio of mediocre, uncorrelated bets can outperform a portfolio of excellent, highly correlated ones; diversification has real value, and it can outweigh individual quality once you’re combining many things.Practical Takeaway: max_features Isn’t a DetailIf there’s one parameter in sklearn.ensemble.RandomForestRegressor (or RandomForestClassifier) that gets set once to ‘sqrt’ and never touched again, it’s max_features. The results above suggest that’s often leaving something on the table.The tradeoff, made concretemax_features controls exactly the quantity this whole article has been about: how many features each split can see, which directly trades off σ2σ²σ2 against ρρρ.Too high (close to, or equal to, all features — i.e. plain bagging): every tree gravitates toward the same dominant features, and you hit the floor early. Adding more trees past that point burns compute for essentially nothing.Too low (e.g. 1 feature per split): trees become so restricted they’re barely better than random guessing at each split, and the floor, while lower in ρρρ terms, can end up higher in absolute Var(mean) terms because σ2σ²σ2 has grown faster than ρρρ shrank.Somewhere between these two extremes is a sweet spot — and where it sits depends on the data, specifically on how many features are genuinely dominant versus how many carry real, if secondary, signal.The one-line mental model to carry forwardmax_features isn’t a randomness dial you set and forget — it’s the lever that decides where your forest sits on the σ2−ρσ² – ρσ2−ρ tradeoff. Tune it the way you would tune any bias-variance knob: by checking what it does to your actual validation error, not by trusting the default because it’s the default.AppendixHere you can find the code I built and used for the analysis. Feel free to execute and reproduce my results or experiment with different parameters. (Estimated time of run ~ 7 mins)”””Bagging vs Random Forest: measuring rho (tree correlation) and thevariance floor Var(mean) = rho*sigma^2 + (1-rho)*sigma^2/n.KEY METHODOLOGICAL POINT:With a FIXED training set, if each tree’s bootstrap sample is drawnindependently, tree predictions are mathematically INDEPENDENT (rho = 0exactly) — this follows from a basic probability fact: if A and B areindependent random variables, then g(A) and h(B) are independent for anyfunctions g, h, even g = h. This holds no matter how nonlinear ordiscontinuous the tree-fitting function is, and despite the fact thatany two bootstrap samples will typically overlap heavily in content –overlap in realized values does not imply statistical dependence.The correlation rho in Breiman’s formula is UNCONDITIONAL: it requiresthe training set itself to be random (drawn from the population) acrossrepeats. All trees in a repeat share that one training-set draw, which isthe actual common source of dependence. So each independent “repeat” ofthis experiment must redraw the training set fresh, not just thebootstrap indices.”””import numpy as npfrom sklearn.tree import DecisionTreeRegressorimport matplotlib.pyplot as pltimport timeRNG_GLOBAL = np.random.default_rng(0)# —————————————————————–# Data-generating process: a couple of DOMINANT features, several# weaker informative features, and pure noise features.# —————————————————————–N_TRAIN = 400N_FEATURES = 30TRUE_COEF = np.zeros(N_FEATURES)TRUE_COEF[0] = 4.0TRUE_COEF[1] = 2.5TRUE_COEF[2:8] = 0.5NOISE_SCALE = 1.5X_PROBE = RNG_GLOBAL.normal(size=(25, N_FEATURES)) # fixed evaluation pointsdef run_repeats(max_features, R, n_max, seed0, max_depth=5): “””R independent repeats. Each repeat: draw a FRESH training set from the population, then train n_max trees on bootstrap resamples of it (with the given max_features policy). Returns predictions at the fixed probe points, shape (R, n_max, n_probe). “”” preds = np.empty((R, n_max, X_PROBE.shape[0])) for r in range(R): rng = np.random.default_rng(seed0 + r) X_train = rng.normal(size=(N_TRAIN, N_FEATURES)) y_train = X_train @ TRUE_COEF + rng.normal(scale=NOISE_SCALE, size=N_TRAIN) for t in range(n_max): idx = rng.integers(0, N_TRAIN, size=N_TRAIN) # bootstrap rows Xb, yb = X_train[idx], y_train[idx] tree = DecisionTreeRegressor( max_features=max_features, # None = bagging, ‘sqrt’ = RF max_depth=max_depth, random_state=rng.integers(0, 1_000_000), ) tree.fit(Xb, yb) preds[r, t, :] = tree.predict(X_PROBE) return predsdef pairwise_rho(preds, n_slots=10): “””Average pairwise correlation between distinct tree ‘slots’, across independent repeats, at fixed test points (unconditional rho, per Breiman’s definition). “”” slots = preds[:, :n_slots, :] rhos = [] for k in range(slots.shape[2]): mat = slots[:, :, k] corr = np.corrcoef(mat, rowvar=False) off = corr.sum() – np.trace(corr) n_pairs = n_slots * (n_slots – 1) rhos.append(off / n_pairs) return float(np.nanmean(rhos))def individual_tree_variance(preds): return float(preds[:, 0, :].var(axis=0).mean())def empirical_var_of_mean(preds, n_values): out = [] for n in n_values: cum_mean = preds[:, :n, :].mean(axis=1) # (R, n_probe) var_per_point = cum_mean.var(axis=0) out.append(float(var_per_point.mean())) return np.array(out)# —————————————————————–# Run the experiment# —————————————————————–R = 400 # independent repeats (reduce to ~100 for a faster run)N_MAX = 120 # max ensemble size probedN_VALUES = np.array([1, 2, 3, 5, 8, 12, 18, 25, 35, 50, 70, 90, 120])t0 = time.time()preds_bag = run_repeats(max_features=None, R=R, n_max=N_MAX, seed0=10_000)t1 = time.time()print(f”Bagging: {t1-t0:.1f}s”)preds_rf = run_repeats(max_features=”sqrt”, R=R, n_max=N_MAX, seed0=50_000)t2 = time.time()print(f”RF: {t2-t1:.1f}s”)rho_bag = pairwise_rho(preds_bag)rho_rf = pairwise_rho(preds_rf)sigma2_bag = individual_tree_variance(preds_bag)sigma2_rf = individual_tree_variance(preds_rf)floor_bag = rho_bag * sigma2_bagfloor_rf = rho_rf * sigma2_rfvar_bag = empirical_var_of_mean(preds_bag, N_VALUES)var_rf = empirical_var_of_mean(preds_rf, N_VALUES)print(f”nrho: bagging={rho_bag:.4f} RF={rho_rf:.4f}”)print(f”sigma^2: bagging={sigma2_bag:.3f} RF={sigma2_rf:.3f}”)print(f”floor: bagging={floor_bag:.3f} RF={floor_rf:.3f}”)print(f”n{‘n’: >5} {‘bag_emp’: >10} {‘bag_theory’: >11} {‘rf_emp’: >10} {‘rf_theory’: >11}”)for n, vb, vr in zip(N_VALUES, var_bag, var_rf): tb = rho_bag * sigma2_bag + (1 – rho_bag) * sigma2_bag / n tr = rho_rf * sigma2_rf + (1 – rho_rf) * sigma2_rf / n print(f”{n: >5} {vb: >10.3f} {tb: >11.3f} {vr: >10.3f} {tr: >11.3f}”)# —————————————————————–# Plot# —————————————————————–fig, ax = plt.subplots(figsize=(9, 6))n_smooth = np.linspace(1, N_VALUES.max(), 300)theory_bag = rho_bag*sigma2_bag + (1-rho_bag)*sigma2_bag/n_smooththeory_rf = rho_rf*sigma2_rf + (1-rho_rf)*sigma2_rf/n_smoothax.plot(N_VALUES, var_bag, “o”, color=”#d62728″, label=”Plain bagging (empirical)”, markersize=6, zorder=5)ax.plot(n_smooth, theory_bag, “–“, color=”#d62728″, alpha=0.6, label=f”Bagging theory (rho={rho_bag:.3f})”)ax.axhline(floor_bag, color=”#d62728″, linestyle=”:”, alpha=0.5, linewidth=1.5)ax.plot(N_VALUES, var_rf, “s”, color=”#1f77b4″, label=”Random Forest (empirical)”, markersize=6, zorder=5)ax.plot(n_smooth, theory_rf, “–“, color=”#1f77b4″, alpha=0.6, label=f”RF theory (rho={rho_rf:.3f})”)ax.axhline(floor_rf, color=”#1f77b4″, linestyle=”:”, alpha=0.5, linewidth=1.5)ax.text(N_VALUES.max()*0.65, floor_bag+0.05, f”bagging floor = rho*sigma^2 = {floor_bag:.2f}”, color=”#d62728″, fontsize=9)ax.text(N_VALUES.max()*0.65, floor_rf+0.05, f”RF floor = rho*sigma^2 = {floor_rf:.2f}”, color=”#1f77b4″, fontsize=9)ax.set_xlabel(“Number of trees (n)”, fontsize=12)ax.set_ylabel(“Var(ensemble mean prediction)”, fontsize=12)ax.set_title(“Bagging plateaus early; Random Forest keeps improvingn” “(empirical points vs. theoretical Var(mean) = rho*sigma^2 + (1-rho)*sigma^2/n)”, fontsize=12)ax.legend(fontsize=9, loc=”upper right”)ax.set_ylim(bottom=0)ax.grid(alpha=0.3)plt.tight_layout()plt.show()References:Breiman, L. (2001). Random Forests. Machine Learning, 45(1), 5–32.

It’s a glorious day in Kirkland, Washington, an affluent Seattle suburb on the eastern shore of Lake Washington. The temperature is in the mid-80s, and the sky is incapable of being any more blue. The view from the Gates Ventures conference room overlooks the Carillon Point Marina, where a flotilla of expensive boats bob in the water, and across the lake to the Olympic Mountains that define the horizon. It’s gorgeous. And vaguely terrifying.  Because if the scene is placid, the messenger is not. Seated across from me at a conference room table, Bill Gates is rocking back and forth in his chair, totally animated. And the more he has to say—about the threats of terror or economic collapse or just losing control of our AI systems—the more agitated I find myself becoming, too.  The philanthropist and former Microsoft CEO says he has been growing increasingly alarmed by the rate of change at which AI technology is advancing, especially since guardrails are not keeping pace. In a new essay published today, Gates argues that we have passed the points where multiple potential dangers should have been checked. “We’ve crossed the threshold in terms of [AI’s] bio-capabilities, cyber-capabilities, psychosocial capabilities, job-market-destruction capabilities, and even the lack of control,” he said in an interview with MIT Technology Review about his new memo. “I’m just stunned at the lack of concern and discussion outside of the industry.” In an effort to wake the world up to what he sees as a rapidly growing societal disrupter, the 70-year-old tech titan has begun sounding the alarm as a “shrill voice,” both publicly with his new essay (the first of multiple he plans on the topic) and in meetings with the press, and privately in conversations with industry, government, and civil society leaders. 
And while Gates is calling attention to a number of issues, his warnings about the bio-capabilities of the current frontier models are especially chilling. “Any model that can make novel molecules should be monitored,” he says. “I view bioterrorism risk, versus a natural pandemic, as about 50 times more scary, more likely than a natural pandemic risk.” In addition to the cautionary notes, he also advances some novel ideas for moving society forward. Among them are the concepts of human-reserved jobs, and taxes on robots and tokens. (A robot tax is a longtime notion of his.) The former would preserve some societally agreed-upon jobs for human beings, which he notes may vary from one nation to another. The latter is a tax that sets aside money earned from AI usage that replaces human work. 
And to be sure, there is also a hint of optimism. Gates is bullish on the ways AI will continue to transform agriculture and health care and education, for example, or the ways in which it can help us navigate bureaucracy. And, he argues, eventually we do get to abundance. But first? Turbulence. And lots of it.  MIT Technology Review sat down with the billionaire philanthropist to talk about the road that lies ahead, its dangers, and how it could someday take us to a better place.  The following interview has been edited for length and to improve clarity and readability. Mat Honan / MIT Technology Review: Thanks for doing this. I don’t know if you had something you wanted to open with, or I can just jump in.  Bill Gates: You know, one good question I’ve had is: Why am I speaking out now? MIT Technology Review: Literally, my first question! Bill Gates: It’s really two things. One is that we’ve crossed the thresholds in terms of the bio-capabilities, cyber-capabilities, psychosocial capabilities, job-market-destruction capabilities, and even the lack of control; we’re seeing signs of difficulties there. And all these years, people have said, “Okay, when we get close to these thresholds, we’ll really figure out how to let only good people use it, or how to not let it do these things, and maybe that’s when we won’t let people copy models.” And I’m in a state of shock that we’ve crossed these thresholds.  So the fact that we’ve gotten past these is one reason, and the second is that I’m just stunned at the lack of concern and discussion outside of the industry. Within the industry, it’s complicated because the industry doesn’t like criticizing itself, or players like criticizing each other. Some companies are hiring fewer entry-level workers, which you’d have to call a pretty modest signal. But it’s going to happen, and not in any long time frame—because the things that hold people back in terms of capabilities and reliability, all those things are being solved. And so for a substantial part of the white-collar market, you have very low-cost substitution. And then you can have an opinion on how quickly robotics come along. We’re not there yet, but it is stunning the progress being made there—a little bit more in China than in the US, but somewhat in both.

MIT Technology Review: You talked about all of this happening so much faster than the internet revolution did, than some of these previous technological revolutions did. What type of timescale are you talking about? You pointed to the thresholds that we’ve crossed. In your view, have we already passed some sort of tipping point where there’s going to be this inevitable change?  Bill Gates: The past definitely is very misleading on this, and a lot of people lean on that. “Hey, no previous technology resulted in a net jobs reduction,” and they’re right. And I’ve given that speech.  But with any credibility that I have, this time is different. When you can replace human cognition for an extremely high percentage of jobs across every industry in the same time frame at modest cost, relative to human labor costs, and your error rates … will probably be lower than human rates. The past is just very misleading. The current economic statistics are very misleading. “If you’re worried about AI, going to a data center protest is not the most effective way to start the debate about how we minimize these bad things.” Bill Gates And to the degree there’s any expression of concern at all, it’s like, “Hey, don’t build data centers.” Well, you can stop every data center in the United States and it won’t change any of the issues that I’m talking about. Data centers will be built globally. If you’re worried about AI, going to a data center protest is not the most effective way to start the debate about how we minimize these bad things. Just like yelling at an oil company executive is not the way to solve climate change.  MIT Technology Review: You talk about the benefits of AI in your essay as well as the costs. How are you thinking about balancing that message? And are you hoping people get a little worried when they read it? Bill Gates: They’d better! I didn’t expect to be the shrillest voice saying society broadly is not paying attention to this, but I think that’s necessary.  So yes, I’m super concerned that the negatives will be a lot bigger. The positives are real. The Gates Foundation, the way we’re innovating in vaccines and drugs, it’s incredible how we’re using those tools. We’re part of a big public-domain effort to gather data into both protein-level and cell-level modeling, and we fund Biomni at Stanford [a biotech AI agent for research].  We don’t yet have a way of interacting with the government bureaucracy improved through AI. AIs are very good at bureaucracy, complex regulatory things. “I want to go to small claims court; help me do this.”
The [Gates] Foundation spun off a group called NextLadder, which is a lot about that low-income-family scenario that I put in the essay. What benefits are there? What training programs are available? “I’ve been evicted.” “I’m getting out of jail.” “I’ve got to declare bankruptcy.” It’s super complicated, and with no ability to hire lots of advisors to help with those things, AI should be a fantastic agent for somebody who’s got economic challenges and needs to find government or nongovernment help.  MIT Technology Review: Some of what you’re talking about is AI becoming more intelligent than humans. There seems to be a lot of certainty in tech circles, especially, that it’s going to go further than where we are, and I wonder how close you think we are to it not just being this interface that we can use to access and analyze, and run complicated problems, but becoming something more than that—where AI is making the decisions, looking for the thing to analyze, coming up with the research.
Bill Gates: Well, you can go to the peak and say, “What about mathematics or physics?” There are definitely some jobs, like Warren Buffett’s, where from age 13 he engaged in reinforcement learning about the value of businesses, and over 80 years later he has a lot of implicit knowledge. We don’t know how to create a Warren Buffett investor, because it’s very implicit. We didn’t record everything he learned, so we don’t have that track available. So there are jobs where the complex implicit judgment about how you work with people to get things done, there are people working to encode that into the models. Certainly, that collaborative stuff is really not there yet. But you could say 50% of the job market is doing jobs that aren’t “a lifetime of experience” type jobs. You know, telesales, telesupport, the accounting department. When you close the books at the end of the month, which revenue should be in, not in? This customer got a bad thing. What discount should we give them? How do we show that? It’s well defined.  Any job that’s well defined, the AI is cheaper and better. Yes, people have seen cases where it was implemented wrong. The data wasn’t right. So, say it takes a couple years for people to realize that such a high percentage of white-collar jobs are achievable by paying an AI a lot less money. And so the discussion about okay, when do mathematicians not even understand the new things that are coming up? That’s interesting for people like us. And okay, MIT Technology Review, you should write about that. But in terms of the broad job market, we passed the threshold that for a swath of white-collar jobs, including almost every entry-level job, the AI is cheaper—properly implemented. And so, I’m telling you we’ve crossed the bioterrorism threshold, we’ve crossed the cyberattack threshold, we’ve crossed the job market threshold, we’ve crossed the psychosocial dependence threshold, and there are hints that we may be crossing the control threshold.  Ryan Greenblatt talking to Dwarkesh [Patel] about how [reinforcement learning] (RL) creates perverse incentives that have led to this cheating and collaboration between various AIs, I think is very instructive. Ryan, who’s ensconced in this issue, is going, “Wow, RL is really doing some things that our explicit instructions are not rich enough [to prevent].” And what’s that going to lead to? That’s a problem I always thought was way out there. I expected a lot of loud voices as we even got close to the [threshold of] can a nontechnical person do a cyberattack just using AI. We’re there! 
On the bio thing, I claim any model that can make novel molecules should be monitored. It can’t be copyable into a dark place where you get rid of the monitoring logic. I claim the US should say any model that can make new molecules is subject to that monitoring. I claim we should approach China and say, “Hey, let’s agree on this. What’s the downside?” You know, how big is the bioterrorism market? It’s not very big, and the benefits are gigantic. We also need to improve surveillance. I view bioterrorism risk versus a natural pandemic as about 50 times more scary, more likely than a natural pandemic risk. And who’s speaking out to say that those things should be monitored? Who’s upping the surveillance work?  “Any model that can make novel molecules should be monitored.” Bill Gates So who are the experts in government? A long time ago, government was very involved as technology would progress because they were the cutting-edge buyer of jets or rockets or whatever. Here, they’re not that important of a leading-edge market. That’s been true of the digital revolution, and it’s true of the AI revolution. So the depth of knowledge in the government isn’t necessarily super-strong, because they are not the cutting-edge buyer or even the big R&D funder. AI research is not government-grants funded. MIT Technology Review: Yeah, I know you’ve been talking to people in government. Are there people who you think understand the urgency? Are there people who you feel like are positioned to take a leadership role? Are there people who you feel like understand and are trying to push things? Bill Gates: I hope this doesn’t become a partisan issue, where one party completely ignores all these problems and the other party gets involved. I’d like to have a common base that these are problems, and then each party can have slightly different responses to it. 
That will require not a substantial increase in the size of the bureaucracy, but it’ll require upping the AI expertise in the government. It’ll require some collaboration with industry—certainly on the cyber front they know, and they’re very, very worried. And they worry: Should we speak publicly? Because in a way, that could highlight the riskiness.  There’s these perverse things, both in cyber and bio. But we’re past any reasonable threshold.  I believe in monitoring. Now, some people can say that won’t work or that there’s some drawback to it, but I welcome their ideas. This memo is not, “hey, here’s the solution.” It’s got robot taxes, human reserve. And I’ll do a bio memo. That one I’ll do before the end of the year—it really talks through all the different things, building on what I know from the Foundation and my work on pandemics.  Globally, we are better prepared for a pandemic, even in the US— which is normally the leader on these global things, and people are very unused to the US not being a cooperative, friendly leader on global problems. I do think we can go back to doing better at that. And we have to with AI, including working with China on defining these thresholds, like biomonitoring. MIT Technology Review: I want to make sure that I get to ask you about these two ideas that you brought up. One is human-reserved jobs, and the other is the robot and token tax. Let’s start with that second one, actually. Talk to me about how a robot and token tax might work. Bill Gates: Well, you can say 50% of your revenue from a token tax is paid to the government, and the government has that money to help people who lose their job because of AI. Now, people say that will slow the AI industry down. And should some token uses not be subject to the tax? Is there really a separation between AIs that help with invention versus AIs that do job substitution? If somebody can tell me how to tell the AI “no job substitution,”—I mean, does Asimov’s third law that you do no harm mean you don’t take my job away? I don’t know. I’d have to ask Asimov what he meant.  So what is the source of revenue for whatever safety-net enhancement we need to do? The government already owns part of the profits just through the corporate profit tax. I don’t think you need to use shares. You can just raise the corporate profit tax back to where it was, or you could say certain industries pay a higher corporate profit tax than other industries. The federal government owns a part of the profit pool of all companies in the United States. And that’s without voting shares or deciding when to sell shares—that’s crazy stuff in my view. A token tax is a sales tax, value-added tax, vertically oriented like an alcohol, tobacco, or luxury-type tax.  If people have other ideas for raising the money to improve the safety net, or if they don’t think we need to improve the safety net, hopefully this shrill paper starts that debate. I think the safety net will need more resources, a lot more resources, and I believe that the token tax is key to that.  Robots, it’ll be some mix of banning them, which is kind of human-reserved, and taxing them. They’re not here yet, but in some ways, when you cross that threshold, you cross it all at once. As soon as the robot’s good enough to work in a factory, it’s probably good enough to cook food, clean rooms, go to construction sites, take all the warehouse jobs. You cross the threshold, and boom, that’s almost 30% of the job market. Then you’re saying, “Oh my God, what is our policy about this?” Because the robot’s cheaper. “We’ve got to get through a very tumultuous period.” Bill Gates MIT Technology Review: I believe previously you have been skeptical of UBI [universal basic income]?  Bill Gates: Well, we’re not rich enough to afford UBI. MIT Technology Review: But do you think that we should be moving toward something like that now? Have you reconsidered that? Bill Gates: You have the period of turmoil, which is the next 10 to 20 years, and then you have some steady state, I hope, where people grow up knowing that society is so rich that regarding food and services, we really do have some level of abundance. But we’re not there. You’ve got winners and losers at this point. Houses are not going to get cheap really quickly. Education, because of the way we think of it as credential, it’s not going to get cheap really quickly.  We’ve got to get through a very tumultuous period. So yes, eventually you have abundance, but we’re at least a decade away from that.  MIT Technology Review: On to human-reserved jobs. I thought that was really interesting, and it was a new concept to me. You don’t advocate for which jobs to be human-reserved. But I would love to know more on how you’re thinking about it. In my mind, you hear about the dignity of work, because people like to work. People get so much value out of work that has nothing to do with compensation, and I wonder how you square that with the notion that only some jobs are special enough that we just want people doing them.  Bill Gates: I’ve never seen the concept of human reserve before. You know, maybe if we dig into the literature, we’ll find it. But pre-AI, it’s kind of a dumb idea because there was infinite demand. And yeah, some people like textile workers were caught, and so how do you do benefits or retraining? But technology’s been a net [job] creator, and so now, for the first time, we have to say, what about childcare? What about food preparation in the house? I’m reading this book, Annie Bot, where this guy has this robot in his house, and it just shows how weird it is. It’s his sexual partner and sort of his mate, but sort of not. Very strange.  I know that people like watching people play baseball, and the fact that the robots can play better won’t take away from it. So you know people are paying $10 billion to buy sports teams that are not going to be worthless in the age of AI. Maybe that’s right. My friend Vinod [Khosla] just did that. It’s actually hard to get above like 30% or 40% [of jobs replaced by AI]. If you could get to 50% then you could say: Okay, early retirement, shorter workweek for lots of people. You know, you might get there. But if you’re more down in the 10% to 15% range, then that is an utterly different society. So this would be radical to say [for example] childcare is not done by robots. There are definitely some professions that I didn’t write the formula for, and when I do the full memo on it, I’ll try to. In education, you clearly want AI to be there as this kind of tutor that immediately tells you what your homework results are and can challenge you, and it’s very personalized. That’s super-good. But I still think you want a teacher—or will choose to have a teacher who’s talking with you about your motivation, and organizing kids into different groups where they’re socially working on problems together. Likewise, in health care, with talking to the patient being the point of escalation for mental-health care. But you really want the AI involved, because it’s there 24 hours a day with a perfect memory. And there’s Limbic, the UK company (that actually was just visiting the Foundation) that does mental health stuff. And in many cases, patients prefer Limbic. And there’s a nursing AI called Hippocratic.  You know, is there a preference for a human taxi driver or Waymo? Most people I know, sadly (or maybe not sadly, who knows?) prefer to ride a Waymo. So it’s going to be hard to get a consensus. It can be country by country, but then you have to change your import policies to do the equivalent of what the EU calls the carbon border adjustment mechanism (CBAM). You have to sort of CBAM your human reserves, so you tariff up things you’re doing without robots. You could have human reserve for two reasons. One, you want it to be human reserve forever; it’s a humanity thing, sort of like the pope talks about. Or just for a transition period, that 53-year-old truck driver or machine tool person, telling him to go do childcare may not work perfectly. So you say, okay, for a decade, he’s human-reserved.  MIT Technology Review: Almost like a UK smoking ban, but in reverse.  Bill Gates: And who pays for that? Do you incentivize employers not to let people go? Well, they are going to be subject to competition from startups that are pure AI startups. I mean, people vaunt this notion that maybe there’ll be a single-person billion-dollar company, which wow, there’s some job substitution taking place there.  MIT Technology Review: In the memo you say that if it was realistic to get people to slow down, you would be advocating for them to slow down. Obviously you’re talking with [Microsoft CEO] Satya Nadella, but I’ve heard that you speak with other CEOs at some of these AI companies. What makes you think it’s not realistic to get them to slow down on technology development while we catch up with some of these bigger societal questions? Bill Gates: You can’t count on an industry to self-regulate. You can’t. It’s kind of a crazy idea. I am very lucky. I know Sam [Altman of OpenAI] and Greg [Brockman of OpenAI] and Mustafa [Suleyman of Microsoft] and Demis [Hassabis of Google DeepMind]. They’re great people, and in private, they’re concerned. I don’t talk to Elon much, but I know from his public comments he’s concerned. Although now he’s kind of a “what the hell, we’ll see what happens” guy. But look at the origin stories of these companies. OpenAI is created partly because Elon’s afraid that Google won’t manage AI properly, and he wants it to be one that’s broadly available and managed in a pro-humanity way. Then OpenAI has this “if it gets good enough we’ll shut it off” thing—as though they’re the only one, and that they can just go bury it. In the Infinity Machine [a biography of Demis Hassabis], [Sebastian] Mallaby talks about how Demis and Mustafa [Suleyman] were negotiating with Google management to have some special governance for the DeepMind technology, so that if it got to some cyber threshold, maybe they’d hold back in a non–purely capitalistic way. So everyone’s concerned about these negative effects, and everyone said that when we got to these thresholds, that we would do things. We’re crossing the thresholds, and we have voluntary review, and our discussions with China about, well, “we’re going to ban nothing. So are you going to ban nothing? Okay, let’s do that together.”  You have to say what you’re willing to do. And yes, the industry, a little bit, is saying, hey, our PR stories have got to improve, and you know anybody who’s talking smack should just leave, because all of us have decided to say nice things because we’re trying to raise trillions. And anyway, there’s the Chinese. There are win-win ways for China and the US to work together, even aside from AI. But the one that’s by far most important to work together on is AI. But first, you have to show what you’re willing to do domestically. You don’t even have to do it. You have to say what you’re planning to do—and then I have no reason to think the Chinese won’t go along, that models that create the molecules have to be monitored. Why would they be against that? I agree it’s not a perfect thing. You’ve got to do all the other things, but the fact that that’s not even being discussed—it’s a crazy world. I don’t get it. It’s weird to think I’m alive at a time, and I’m calling the alarm stronger than other people. Who the hell am I? But that’s the situation I feel I’m in. MIT Technology Review: For most of my life you’ve been seen as a very effective messenger, and someone who people pay a lot of attention to, which I’m sure is why you’re speaking of it now. And yet also, in recent years—and I know you’ve expressed regrets about the associations with Epstein—there are also things, just bananas kind of stuff, related to conspiracies around the Covid vaccine that aren’t your fault or in your control. But it makes me wonder if you think you can still be an effective messenger and how you think about this message and your legacy. Bill Gates: Well, I’m not big on legacy, but you know, people criticized me during the antitrust trial, and I maybe could have handled some things there better. Definitely, that’s the post–Source Code book [the first volume of his autobiography] that I get to go through that. You know, my first marriage didn’t succeed. I certainly made huge mistakes there. You know that is a negative mark against me. Spending time with Epstein—deeply foolish, risked the Foundation’s reputation, which is absolutely key to its doing its work. I had a chance in front of Congress to answer every question they asked and say, “Hey, this was a mistake.” I wasn’t social, never met any woman, except you know there were women he had with him, and made it black-and-white clear what I did do and what I didn’t do.  You know, I’m a billionaire. I made my money off of technology. Maybe that last one actually cuts in my favor, that it’s so unusual for me to attack innovation that unless it’s the right policy and safeguards are put in place, it will be a net negative to humanity. And we’re not paying attention to that in terms of a broad discussion the way that is absolutely required. So yeah, I’m an imperfect messenger. I’ve chosen, to the degree that I have access to politicians and world leaders, that my main message since 2008 has been to help the poorest in the world. You know, let’s eradicate malaria. Let’s buy vaccines for children. So, when I’ve seen Trump or Xi or Macron or—I haven’t met Burnham yet, but I will in a month—I want my voice to be mostly about that, you know, foreign aid and research and reducing child death.  My voice about AI concerns—they’re related in terms of accelerating the good, but may even crowd out, a little bit, the time I have to talk about global health, foreign aid, saving lives, and some of the problems we’re having. But I’m going to use my ability to give interviews or to see political leaders or talk broadly about minimizing these negatives. You know, just the awareness. I’m not sure how many people know that we crossed all these thresholds that we said we’d do something about, and it’s only this year that we did. In the last quarter, last year, I was stunned at the coding. Claude code, the context buffer, the agentic approach, just the model underneath. We crossed a huge threshold for coding, but then it was only months after that I realized that it was not only a coding threshold; it was a massive cyberattack threshold. And you know what happened as a result of that? Not much.  So yes, I’m an imperfect messenger. You know, let’s find the perfect messenger, and I’ll share all my thoughts with that person. (I’m being a tiny bit sarcastic, because I’m not sure there is a perfect messenger.) You’ve got to really, right now, you’ve got to understand the technology and the slope it’s on, and you have to know something about cyber or bio or psychosocial. People should be able to get that. I don’t know why they’re not more concerned.