Reading Room

Stripe, the payments company, has agreed to buy OpenRouter, a service that lets apps switch between different AI models depending on price and quality, for more than 7 billion dollars, according to a Bloomberg report over the weekend. Neither company has confirmed the deal yet and the price could still move before it closes.

This is on his desk because it is a real data point on where money is flowing in AI infrastructure right now, not another funding rumor. OpenRouter raised money at a 1.3 billion dollar valuation only three months ago, so this deal values the company at more than five times that price in a single quarter. Three weeks ago, talks between the two companies were reportedly near 10 billion dollars, so the final number is about 3 billion dollars lower than that. The newsletter frames that drop as the real story: a sign that OpenRouter's fee income, what it earns for every AI request it routes, looked weaker once buyers looked closely.

If it closes at the reported price, this would be the largest acquisition in Stripe's history. The newsletter frames the deal as Stripe extending its reach from owning payment rails to owning the pipes between apps and AI models, the plumbing that decides which model handles a given request.

The source material beyond this point sits behind a paywall, so the deeper detail on Stripe's reasoning and exactly what fell out of the 3 billion dollar price cut is not available here.

This is worth reading because you hear the tax policy explanation for inequality constantly, and Paul Graham, the Y Combinator co-founder, makes a sharp case that it is mostly wrong. His argument: the real driver is that starting and scaling a company has gotten dramatically easier, and that same force is the leverage you are building into your own work with AI tools.

Graham compares the Forbes list of the 100 richest Americans in 1982 and in 2020. In 1982, 60 of the 100 had inherited their money, including 10 heirs from the du Pont family alone. By 2020 that share had been cut in half, to 27 of the top 100. The shift is not that fewer people are inheriting fortunes, it is that more people are making new ones.

Of the 73 new fortunes on the 2020 list, roughly three quarters came from starting companies and about a quarter from investing. In exact terms, 56 came from founders' or early employees' equity, 52 of them founders directly, plus 2 early employees and 2 founders' wives, and 17 came from running investment funds. No fund manager cracked the top 100 at all in 1982.

The bigger shift is in what kind of company makes people rich. In 1982, oil and real estate together accounted for at least 24 of the 40 new fortunes. By 2020, oil and real estate combined for only 6 of 73. The largest source in 2020 was technology companies, about 30 of the 73 new fortunes, including 8 of the top 10 overall. Graham pushes on the label: is Amazon really just a retailer, is Tesla really just a car maker? His answer is no, because what unites these companies is winning through better technology rather than through deal making. No ordinary retailer starts a business like Amazon's cloud computing division, and no ordinary car company is run by someone who also runs a rocket company.

Graham's twist is that 1982, not 2020, was the unusual year. In 1892, a New York newspaper counted 4,047 millionaires in America. Many of those 1892 fortunes came from the new technology of mass production. By the end of World War II most of the economy ran through a small number of large, oligopoly style corporations. In 1960 you could not easily start a company and break through those giants, so the path to wealth was climbing the ladder inside one of them, not building your own.

Graham has a pointed answer for anyone treating 1982 as the fairer era. In 1982, 84 percent of the 100 richest people got their money by inheriting it, extracting natural resources, or doing real estate deals. He asks whether that is really a better world than one where the richest people get rich by starting technology companies.

The reason this lands for you specifically: AI tools are lowering the same barrier Graham describes, the cost and time it takes to start and scale something. A decade ago a solo founder needed a team to ship software; today one person with the right tools can build, test, and launch alone. Graham's argument is that this kind of leverage, not tax law, is what has been reshaping who gets rich. It is also, almost exactly, the bet behind the agent fleet and leveraged income systems you are building.

Put plainly: the shift is not who Washington chooses to tax, it is who can now build something valuable fast, alone or with a tiny team, and watch it compound. That is Graham's whole point compressed into one line, worth having ready the next time inequality comes up as a tax argument.

This is directly useful for how you think about your own AI-leveraged building: a working software engineer argues that as AI writes more of the code, the judgment to choose the right approach and catch what the model gets wrong becomes the actual skill, not a fallback for when the tool fails.

The author frames this against the noise online: a lot of talk about "agentic engineering" (AI systems that take multiple steps on their own, like planning, writing, and testing code without a person typing each step) either oversells what is possible or declares the software engineering profession over. In their own experience, and watching friends, the people doing the most impressive work with these tools are rarely the ones posting about it. They are quietly finding the leverage points and using them.

The author says AI coding tools crossed a real capability threshold in the past year, and says the barrier to running them is shrinking fast. Open weight models, meaning versions of the AI that anyone can download and run themselves, now run capably on a strong personal computer, not far behind the best commercial models.

The author's core claim: getting an AI tool to produce working code is only the start of the job, not most of it. With foresight, AI-written code can be made to work and to pass tests, especially by explicitly prompting for test-driven development (writing a failing test first, then writing code that makes it pass). But above that baseline, the "seams", how a piece of code's interface behaves and how it fits with everything else around it, are still mostly art, not science, shaped by the engineer's judgment and experience.

The reason AI tools stall there: large language models, the AI systems behind tools like Claude and ChatGPT, do not actually reason. They predict the next likely piece of text based on a compressed version of human writing, so they can echo human reasoning when it was written down somewhere, which is different from doing it. The author points to a paper called "The Illusion of Thinking" on how weak current models are at genuine reasoning, and flags a separate, more promising research thread called world models, associated with the researcher Yann LeCun, which tries to have a system predict what will actually happen after an action, rather than just predict the next words.

One craft note worth keeping: the author raises what the developer Simon Willison named the "lethal trifecta": AI models cannot reliably tell good instructions from bad ones, which is why they stay vulnerable to prompt injection, hidden instructions buried inside text the model reads and follows. Limits on what the model is allowed to do reduce that risk but do not close the gap.

The author's closing point is a craft one: there is never a single right answer for how to build something, it is always a tradeoff, choosing what fits the specific problem. As more people reach for AI tools because a task "looks easy to implement", the author argues the old skills, managing how much a person needs to hold in mind at once, and deciding which parts of a system should stay fixed and which should be free to change, matter more, not less.

This is worth your time because it is a real world attempt at the exact hard problem behind your own memory and agent work: how do you make an AI system remember who it is and what happened, across sessions that would otherwise be completely disconnected.

The author watched the Black Mirror episode "Plaything" (season 7, episode 4), which features the Thronglets, and got stuck on a narrower question than the show asks. Not whether you can create digital consciousness, but what it would actually take to build an AI system with enough continuity that it stops feeling like a pile of separate, disconnected sessions. That question turned into a project called Lunar Citadel: a small artificial city, built over months, with recurring characters who have distinct identities, histories, and relationships, plus places, institutions, memory, governance, and a running history of cause and effect.

The engineering layer underneath is what the author calls the Citadel Runtime. Its job is to give the city an actual mechanism instead of relying only on written prompts and story text: persistent state, meaning information that survives between sessions instead of resetting, bounded agency, meaning limits on what each character can decide or do on its own, plus memory, recovery from errors, and consequences that carry forward when the world changes. The author is explicit that they are not claiming the system is alive or conscious. Their real question is how much structure you can build around AI models before a system stops behaving like "a chatbot with lore" and starts behaving like a place with an actual history and social continuity of its own.

The side effect surprised the author more than the project itself: building this connected them with a scattered group of people working on the same underlying problems from different angles, AI agents, persistent memory, organizing what information a model sees at the right time (what the author calls context engineering), long running assistants, artificial societies, and questions of how an AI system's actions can be traced back to their source. That led to a small private group chat, kept small on purpose, for people building what the author calls "weird personal infrastructures that don't have a proper category yet". Joining does not require contributing to Lunar Citadel itself. Sharing your own project, disagreeing, or just watching what others build all count as valid participation.

It is a small, low pressure way to compare notes with people solving overlapping problems, rather than a formal collaboration.

The overlap with your own work is direct. The unglamorous plumbing this author is wrestling with, giving an AI system a memory that persists, deciding what it is allowed to do on its own, recovering cleanly when something breaks, is the same category of problem behind the cross-project memory system you are building. It is a useful data point that someone solving it from a hobbyist, world building angle keeps running into the same load bearing questions: what should persist, what should be bounded, and how do you recover state without losing the thread, and that the wall is the same whether you are building a founder's operating system or a fictional city.

Most teams check fairness only after training, then call a quick demographic scan "responsible". The piece argues that is backwards: when past data already treats groups unequally, a model learns that as normal. Its example: a credit model scored a strong 0.87 AUC score overall, yet had a false alarm rate nearly double for one group, a gap over 0.18 on a standard fairness measure.

A Reddit poster noticed a data center builder going public, which signals investors expect years of demand, not a short spike. Their question: will the biggest cloud companies keep building at this pace for 25 more years, or scale back once today's centers just need maintaining. Worth sitting with as you weigh how durable the AI buildout really is.

Outside your usual reading: the full fourth edition of "Linear Algebra Done Right" is free online under a Creative Commons license, in English, Chinese, Farsi, Greek, and Portuguese. It is aimed at undergraduate math majors and graduate students, and the fourth edition adds over 250 new exercises and over 70 new examples. Worth bookmarking for the next time linear algebra needs unpacking.

Outside your usual reading: the free image editor GIMP is building a new project file format to replace XCF, in use since 1997, moving to a zipped XML structure that saves faster. Old XCF files will still open. A reminder that plenty of solid software keeps improving quietly, outside the AI news cycle.