Log in
This event summary was created by Claude with editing by Tim O’Reilly, based on a transcript of the conversation.
Alex Komoroske is the CEO and a cofounder of Common Fabric, a public benefit corporation building the infrastructure for human-centric agentic computing. He spent more than a decade at Google as a product manager and director of product management on Chrome, Google Maps, and Google Earth, and he later ran corporate strategy at Stripe. At O’Reilly’s AI Codecon a year earlier, in a talk called “Why Centralized AI Is Not Our Inevitable Future,” he argued that we were sleepwalking into the wrong future for AI and didn’t have to accept it. Since then he has coauthored the Resonant Computing Manifesto, which Tim signed.
On Tuesday, October 20, 2026, Tim O’Reilly hosted Alex for an hour-long conversation, “Can We Build More-Human Technology?” Common Fabric’s consumer product hasn’t yet been released, but Alex showed Tim the product privately the day before, and Tim said his conversations with Alex had left him “more optimistic about the future of the web and the AI future than I’ve been in a long time.” They talked about the underlying theory behind Common Fabric.
The Resonant Computing Manifesto
The Resonant Computing Manifesto lays out five principles for resonant technology. It is private, meaning you’re the steward of your own data and it’s used in accordance with your wishes. It is dedicated, with no conflicts of interest. It is plural, with no central entity holding an unnecessary amount of power. It is adaptable, able to do things its creators didn’t specifically build in. And it is prosocial, helping people create meaning together rather than living as “individual islands.”
According to Alex, the manifesto rests on a distinction between two kinds of experience.
A hollow thing is something that you like when you’re using it, and then, after you’re done using it, you’re left feeling regret. And a resonant thing is something that you like when you’re using it, and then afterwards you’re left feeling nourished. They are superficially very similar, but they’re fundamentally, deeply, structurally different.
Alex argued that modern tech, business, and politics are very good at delivering hollow experiences efficiently and poor at delivering resonant ones. The manifesto came from a group of people who still believe in the hacker ethic of the 1990s and early 2000s, he said. They believe that technology is a large positive force for humanity, but also that the industry has spent the last decade optimizing for engagement and extraction, which has undermined that positive impact. They think that the AI transition is a unique opportunity to reset the norms and the architecture to make something that works better for people than for extractive business models.
Privacy, bits, and the physics of trust
Tim started out by asking Alex to go a bit deeper on privacy. Privacy and trust are related in ways the privacy movement often doesn’t consider, Tim said. We don’t put bars on all of our windows. We trust most people not to break in because we built a society where trust is the norm. It’s held in place not just by penalties but by social rewards for people who follow norms. “People will think you’re a creep if you go look into somebody’s window,” Tim noted. Like bars on the window, hard privacy seems to Tim a bit like an admission that we’re giving up on positive social norms and penalties for rulebreakers (where needed). He wanted to know whether Alex meant “private” in the way that HIPAA makes your healthcare records private, where your data is made hard for anyone to see, including you.
Alex doesn’t mean that at all. He means privacy that makes your data more useful by putting it under your control. He gave a three-part answer about how that happens. The first leg of the stool is what Helen Nissenbaum, a professor of information science at Cornell Tech, calls contextual integrity. What she means by that is that your data is used in line with your intentions and expectations, with no use that harms you, and no nasty surprises. Alex said it’s the best formulation of privacy he knows. Tim agreed.
The second part of Alex’s answer was that there are differences between atoms and bits. Arguing from game theory, Alex suggested that trust emerges when you expect to deal with the same person or entity again. In the physical world, you might be seen peering into someone’s window and shamed as a result. But “in the world of bits,” because the peeping is invisible, there are fewer immediate consequences, and “you can have a whole bunch of creepy companies peering through your window.” And because your data becomes more useful when combined with other data, there are much larger financial incentives to misbehave. (Tim would still argue that we also need to establish the right set of social norms and laws for regulating this bad behavior.)
The third point Alex made is that data is viral. It can be copied at full fidelity, instantly, for almost nothing, so once it’s out of your sight, it’s out of your control. The industry has relied on three inadequate mechanisms to address this: 1) terms of service nobody reads; 2) permission dialogs, which Alex called “responsibility-laundering dialogs” (He argued they ask an ill-posed question, whether you trust another entity, open-ended and forever, with your data. “I trusted 23andMe with my genetic data 10 years ago, and I sure as hell don’t trust them now,” he noted.); and 3) silos, where each app sees one slice of you. Spotify knows what you listen to and Strava knows when you work out, but neither knows which songs you like during a workout.
Alex said he respects Google, where he worked for many years, but he argued that it has little incentive to build much on your data beyond keeping you from leaving. His point was that “our data is kind of sitting there, not really working for us, and also not really on our turf,” and that this is the result of technical decisions the industry made rather than a law of nature.
Data that carries its own rules
Tim asked what makes Common Fabric different. A lot of people have espoused ideals like those of the Resonant Computing Manifesto, though perhaps in different words, but not much has changed. Alex replied that resonance is hard to build today because users spend their time on the software creator’s turf, doing what the software creator wants. Unless that structure changes, engagement-maxxing keeps emerging. Common Fabric goes down to lower layers and does something very different with the very structure of data. Alex said Steven Levy, writing about the manifesto for WIRED, had described what Common Fabric is working on as “resonant AF.”
Conceptually, in Common Fabric, every piece of data carries a metadata sidecar wherever it goes. In that sidecar, there are two things. One is cryptographic provenance: who did the last computation, the fingerprint of the software that did it, and what its inputs were, traceable all the way back. Alex said the math is similar to blockchains, but without a globally consistent, financialized ledger. The other is policy, the conditions under which the data may be declassified, now or in the future.
An open source runtime, which Alex called “the core reaction chamber” of Common Fabric, enforces those policies. It receives a proposed graph of computation, made of untrusted code running on specific data with specific policies. If the computation is legal, the runtime runs it, updates the provenance chain, and tells everybody. If not, it stops with a descriptive error, for example because a network request could leak something derived from confidential data. You can run the runtime on your own machine, but most people won’t, so Common Fabric will run it in the cloud in trusted execution environments. These are hardware-isolated environments where the host can’t see inside and can prove cryptographically that it’s running the runtime unmodified.
Tim raised a worry from the history of security software. Early systems such as Kerberos were so complicated to set up and maintain that few people used them. Would this be a master console of access controls so complicated that nobody ever touches it? Alex said most users will never know how it works. To them it will simply be “the best way of using AI in their lives,” a digital home where their data, their collaborators, and their agents come together.
The software in that home is made of what Common Fabric calls patterns, small chunks of untrusted code. Alex stressed that he means “untrusted” in the security sense, which is good, because rather than meaning “not trustworthy,” it means “you don’t have to trust them.” Patterns are written in TypeScript and look much like React. (When the team asked LLMs what framework felt most natural to them, the models said React.) A pattern can do six things:
- It can do arbitrary computation.
- It can produce derived data, which persists and is available to other patterns.
- It can produce UI for different contexts, such as dark mode or a preview chip, computed only when used.
- It can make network requests if policy allows. (LLM calls are technically network requests.)
- It can instantiate subpatterns fetched from anywhere on the internet, or written by an LLM on the fly.
- It can wish for more data.
Alex walked through a wish. A meal-planning pattern wishes it knew the user’s favorite foods. In one pattern, the system might express this wish by asking an LLM to generate a simple text box for the user to fill in. Another pattern might look for notes tagged “favorite foods” or for the ingredients in recipes the user made in the last six months. Another might read through the user’s Gmail with an LLM and distill what they like to eat. Because the emails are confidential, the result is confidential too.
That pattern could have been written by a stranger and could still run proactively on your data, Alex said, because Common Fabric is designed so that the pattern’s author never sees your data and the pattern can’t use it against your expectations. Anyone can write new patterns (kind of like skills) and Common Fabric will surface the most popular ones for various tasks.
Type checking for your data’s rules
Tim asked Alex to slow down on this point, that you can give untrusted software access to your data because the data, not the software, decides what may be done with it. Alex replied that users will rarely think about policies. Users would choose default policies that are vouched for by people and organizations whose judgment they trust. For instance, he said “I trust Simon Willison. And Simon Willison will say, ‘I trust that repo right there.’”
Alex gave as an example a pattern that pulls your Gmail into Common Fabric. It uses an OAuth flow to get a token from Google. Anyone who has that token can read and send your email indefinitely. So the token is tagged with a policy “secret to google.com,” which specifies that the token should never be logged or shown on screen or sent anywhere that isn’t attested to be running the runtime, not even the user’s own browser. It may cross the network only over a secure connection to the origin that minted it, and only in the authorization header. Any pattern that looks at the token, or at anything derived from it, absorbs those policies permanently. “You can look at the OAuth token, but then you can never talk to anybody else ever again, basically.”
Tim said this sounds like the virality of GPL licenses. Alex agreed, and said that Mitchell Baker, the Mozilla cofounder, had made the same point to him a few weeks earlier.
The term of art in information-flow control is “taint,” (a term Alex joked he dislikes because people look at him funny when he uses it). Data is tainted when it has touched something confidential and so inherits that thing’s restrictions. The aim is to keep as little data tainted as possible so that network requests can still happen safely later. Common Fabric’s compiler untangles a pattern’s data flows so that code which only passes a token along gets a handle to it rather than the token itself, and stays untainted. Alex compared this to Rust’s borrow checker, which refuses to compile code that could theoretically have a data race. Human programmers find it a nag, and a slog.
But you know who doesn’t get impatient about that? LLMs. They don’t care. They’ll say, “Okay, cool. I’ll just make this tweak.”
There’s something different at work in the world.
This is the heart of Alex’s answer to Tim’s question about the risk that complexity will make the system unusable. Common Fabric’s taint checker nags in the same way as Rust’s borrow checker, and LLMs grind through it. “If this software compiles, it’s safe structurally,” Alex said. “You don’t know it’s useful, but you do know it’s safe.” Because it’s safe, the system can run patterns for people proactively and speculatively, without their installing anything, and then share more widely the ones people engage with. Alex said that kind of distribution isn’t possible under the trust model normal software uses.
Crappy patterns and dangerous patterns
Tim noted that the word “pattern” comes from Christopher Alexander’s A Pattern Language, the book about why some buildings and places work and others don’t. Alex added that the manifesto quotes Alexander directly, and that he considers resonance to be Alexander’s “quality without a name.” Tim recommended the book to anyone who hasn’t read it. He recalled patterns such as Alexander’s observation that balconies and porches less than six feet deep are rarely used, and his question of why people sit on stoops in some neighborhoods and not in others. Then he asked, “Won’t people just start making shitty patterns?”
Alex said they will. Most videos on TikTok are bad, and social sifting still brings the good ones to the top. He gave a stylized example of a ranking function. To decide whether to show images at the top of search results for a query, you can check how many people in the last 90 days searched for “images of” that term compared with the term alone, and show images above a threshold. The authentic behavior of a small group of savvy users tells you about quality for everyone else.
“I’m not worried about crappy patterns,” Alex said. “I’m worried about dangerous patterns.” He’s thinking about patterns that would misuse your data. And that’s what Common Fabric is designed to prevent. His example was the draft box in a chat app. Everyone assumes what you type is visible only to you until you hit send, and then only to the people in the chat. Nothing in today’s software structurally guarantees that, and on some marketing sites, the support agent can see what you type before you send it. In Common Fabric, a default policy could make the draft structurally confidential until the Send button is pressed and then declassify it to only the chat’s members. No chat app assembled from this pattern could behave otherwise.
Tim noted there will be a long period of discovering corner cases once the system is out in the wild. Alex said two surfaces must coevolve, the open-ended set of patterns and the policies, which is why trust delegation matters. As people find patterns that slip past common default policies, the policy sets need to evolve to meet the threat. He said he isn’t promising perfect security, which he called an asymptotic ideal. His claim was that for the same security budget, users can reach further.
Today, in the physics of trust we use, a more secure system requires putting yourself in a smaller and smaller and smaller box. What if, instead, a more secure system puts you on a taller and taller platform, allowing you to reach much further?
People won’t come for the security model, he said. They’ll come because they can do much more with AI and with collaborators than other software allows, and the security model is the reason that isn’t creepy or dangerous.
Where’s all the new software?
Tim brought up a question he has written about previously. When a new technology arrives, at first people can see only the old one. When the web came along, Marc Andreessen talked about Netscape becoming the next Windows, and even open source developers talked about a Linux desktop and an open source Photoshop, while the real action was people making entirely new things with the web. With AI, Tim said, we hear about a world of infinite software, but he hasn’t seen many accounts of wonderful new things people have built. Mostly he hears about dark factories that help people get more productive at what they already did. People talk about the tooling but not what they built with it. Patterns, he said, gave him a taste of what infinite software might really be.
Alex said software today orbits corporations, when it should orbit people. He described a “nightmare” in which building software took excruciating, hypermeticulous detail and bickering with dozens of people, and then pointed out that this was how software was built nine months ago. Old software now inspires in him the kind of awe people feel at the pyramids, built without heavy machinery. “And yet where is all the new software?”
His answer was that infinite software built on the old physics of trust can’t produce the things that matter. On one vibe-coding platform, he found a dream-tracker app by an anonymous author that lets you log in with Google, store dreams, and mark some of them public. He started to enter a dream and stopped, because he had no idea whether the author had left everything public by mistake or was reselling it. The old trust model worked tolerably, he argued, because expensive software usually came from people who knew what they were doing, and big companies had lawyers telling them not to sell your data. When anyone can bring software into existence, even that level of trust goes away. Without new physics for distribution and trust, infinite software gives you either “cozy bits of software” from people you would trust alone in your house for an afternoon, or isolated islands that can’t touch sensitive data and “top out at microgames and art apps.”
Software is alchemy. It is our ability to extend our agency beyond ourselves and automate it. And so the idea that software is going to top out at these very low things is just ludicrous to me.
Reclaiming your data
Tim connected Alex’s point about trusting big companies to his own analysis of rising tide rents and robber baron rents, which he developed around the same time Cory Doctorow was writing about enshittification. Companies have strong incentives to treat users well while they’re acquiring them. Once growth flattens, the incentive shifts toward taking advantage of users, staying just good enough that they don’t leave. Part of what keeps people attached even as applications enshittify, Tim said, is that the apps hold so much of their data.
Alex agreed that reclaiming data is the right frame. The business model of the last decade, as he described it, was to build expensive software aimed at an average market, let user data accumulate, and then rent access back, sell derived insights, or hold the data hostage. In a world of infinite software, users can build what they want on their own turf, and he expects silos to become “greedy goblins” guarding the data. He drew a line between what silos add and what users put in. Insights a company derives are its own, but the bits a user contributed should come back out. Infinite software, he said, also tilts the cat-and-mouse game back toward users.
Tim asked how he would get 15 or 20 years of email out of Google. Alex gave Google credit for some of the best APIs, especially in Europe. Alex pointed to msgvault, an open source project that keeps a local archive of a Gmail history, so agent queries go to a local copy instead of rate-limited APIs. When services hand over data in deliberately annoying forms, such as a thousand-page PDF, an LLM can patiently restructure it. “They don’t get bored of a task the way you do.”
Who pays for the compute
Tim pushed on the economics. Services like Gmail are expensive to run, and users get them for very little. If he stores terabytes of email himself, he’s paying someone else, possibly more than Google charges, since Google had ways of subsidizing it. How does this work over the long haul if Common Fabric becomes a new paradigm?
Alex began by acknowledging the value these services have delivered. Free turn-by-turn navigation is now taken for granted, though about 15 years ago, he said, the main licensors of that data charged something like five dollars per user per month. Then he made a point he expected some people to find provocative.
If you aren’t paying for your own computation, then it’s not working for you; it’s working for somebody else.
Users would pay for their own compute by running the runtime on their own machines, or through hosts Alex called AI service providers. These would run the runtime in trusted execution environments, prove they can’t see inside, and charge for tokens, compute, and storage. If users could switch providers, margins would stay small. Alex acknowledged that consumers have long resisted paying for software, but argued that the nontrivial marginal cost of LLM tokens creates an opening, much as people pay a monthly cell phone bill because the service has become indispensable.
Tim suggested companies like Google could migrate many of their services into this world. Alex said there will be many opportunities, but incumbents are used to another business model. He recalled telling a friend with a startup that building on the Common Fabric was wildly premature and that his investors might not like it, because the point is that patterns use data without owning it.
Tim noted that today’s model doesn’t have to stay the model, and Alex said he expects new business models to emerge. Asked how he will get developers to write patterns, Alex said he doesn’t need to. Agents write them on users’ behalf, and once someone’s agent has ground through building a word search, anyone else can use that pattern.
Is surveillance capitalism inevitable?
An audience member, David, wrote that he loves Shoshana Zuboff’s The Age of Surveillance Capitalism and wondered how we came to accept as inevitable that companies take our behavioral data. He said he wasn’t sure technology could fix something technology didn’t cause.
Alex said he thinks technology did decide this but allowed that people may disagree. The same-origin policy, the browser rule that lets a script use only data from the site it came from, was introduced by Netscape in 1995 as a quick fix for a security problem that was discovered early on with JavaScript. As more APIs were added, the walls grew higher, and when native apps arrived on iOS and Android, the same model meant every app owned its own data. Alex said that decision could have been made differently. Surveillance capitalism may keep emerging, he said, but it isn’t inevitable, and technology applied at the right leverage point can lead to a different result.
Tim told David he thought Zuboff’s book had a fundamentally bleak view of the world. For a long time, he said, we had a fairly virtuous set of relationships with many of these companies, and then we created economic incentives that led them to treat us badly. He argued that economic redesign is needed alongside technical redesign. That redesign starts with eliminating the market’s requirement that companies always keep growing even when they no longer deliver additional value.
Alex brought up Eric Ries’s book Incorruptible, which he said he keeps a stack of near his desk. He described himself as a believer in markets and capitalism as an emergent force for good. He distilled the book’s thesis down to the idea that organizations that think long term naturally attend more to their externalities. Common Fabric is set up as a public benefit corporation, and Alex said Eric consulted on structuring it to keep a long-term perspective in perpetuity, advice that Eric is now sharing with the wider world through Incorruptible.
Tim’s argument: AI as a reset
AI is a reset the industry still hasn’t yet taken full advantage of, Tim noted. We’re still thinking in the surveillance-capitalism frame, he said, in the same way that Netscape assumed people would buy software and that whoever controlled the software would control the future. We assume a world of advertising, and a world where companies hold more data about us than we do about ourselves. But new AI native companies will find new business models. Tim called Common Fabric the most thoughtful take on this reset he had seen. He compared it to his first encounter with the web, when there were about 200 websites and O’Reilly put it in The Whole Internet User’s Guide & Catalog because, as he put it, “this is the future.”
Tim said he couldn’t promise that Common Fabric would be the winner, but it is the most promising new thing he’s seen in a long time. He recalled the early days of the internet, when it wasn’t clear whether Gopher, the World Wide Web, or AOL would prevail. The web won, in his reading, because it built an architecture of participation. It was easy to draw from and easy to add to, and its mechanisms kept evolving, so that the web of 2000 or 2005 looked very different from the web of 1991. Common Fabric comes with that same sense of open-ended possibility.
Open source underneath, a product on top
Alex said the underlying runtime and pattern system are open source, but on their own they feel like a tech demo, which is why Common Fabric is building a consumer product on top. That product is still in development and not yet public. But he expects strong network effects as more people join the open ecosystem. Tim said that when Alex showed him the product the day before, this idea made sense. He described his takeaway as agents building throwaway software that embodies a shared set of patterns, with data that carries from the beginning the scope of what can be shared with whom.
Alex said none of this would have been possible before AI could write software. He told the story of his cofounder, Berni Seefeld, who had been thinking about these ideas for decades. Over a dinner a decade ago, Alex asked how they would ever get people to write enough patterns to reach critical mass. Berni said that in the future, AI would write software. Alex replied, “Come on.” Berni gave the structural argument for why software engineering would be the strongest, fastest, and most invested-in vertical, and a few years ago told Alex the curve was happening and it was time to start. Not needing humans to write patterns, Alex said, lets us think much bigger and differently from how the industry has assumed software must work for the last 30 years.
Tim closed on that point. Because agents building software in Common Fabric do it according to principles that put people at the center, he said, the nature of the game changes.
