For twenty-seven years, it was dead.

This weekend, I brought it back.

Subscribe now

I pointed an AI agent at those artifacts and asked it to figure out what the game was—and rebuild it. A game that originally took me six months to code, with a team of Game Masters building the world over years, came back to life in a weekend of agentic engineering.

The Game That Helped Build an Industry

If you’ve played any modern MMO, you’ve touched something that traces its lineage back to text-based multiplayer games—MUDs. Before World of Warcraft, before EverQuest, before Ultima Online, there were these strange, beautiful text worlds where you typed commands and your imagination rendered the graphics.

The lineage runs deep. Richard Bartle co-created the very first MUD in 1978 at Essex University, and later developed the Bartle taxonomy of player types—Achievers, Explorers, Socializers, Killers—a framework that still shapes how we think about player motivations in every online game today. Raph Koster, who went on to design Ultima Online and Star Wars Galaxies, has documented this lineage meticulously in his Online World Timeline. MUDs were the primordial soup of online gaming.

Legends of Future Past was part of that wave. It won Computer Gaming World’s 1993 Special Award for Artistic Excellence—the judges wrote that they were “overwhelmed by the creative power of storytelling and fertile liveliness.” The game pioneered things we now take for granted: one of the earliest crafting systems in online games, skill-based progression without arbitrary level caps, and paid Game Masters who ran live narrative events. People who cut their teeth as GMs and developers on LoFP went on to work on Star Wars Galaxies at SOE, founded studios like Worlds Apart Productions, Dejobaan Games, and Magic Soup Games, and shaped the trajectory of online worlds.

But like most online games of its era, when the servers went dark, the game simply ceased to exist. No archive. No emulator. Just memories and a Wikipedia page.

This is a pattern that should worry anyone who cares about creative history. The Video Game History Foundation found that 87% of classic games released before 2010 are no longer commercially available. For single-player games, at least the software artifact persists somewhere. But multiplayer online worlds? They only ever lived on servers. When those servers shut down, the world vanishes. It’s as if someone burned every copy of a novel and demolished the library that held it.

Some communities have fought back. Ultima Online still runs official servers nearly three decades later, plus hundreds of fan-operated “freeshards.” Star Wars Galaxies, shut down by SOE in 2011, lives on through SWGEmu and SWG Legends. City of Heroes was resurrected by fans and officially licensed by NCsoft in 2024. But for every EverQuest with a Project 1999 keeping the flame alive, there are dozens of worlds—WildStar, The Matrix Online, The Sims Online—that are simply gone. No emulator. No private server. No way back.

A Weekend Resurrection

I didn’t plan this as a weekend project. I’d been thinking about it for years—wondering if the game could be reconstructed, knowing the source code was long gone. What changed everything was a convergence of two things: old files and new tools.

Here’s what I had to work with. Some of our original Game Masters had held onto their script files for nearly three decades. A complete set of files in a custom scripting language I’d invented at nineteen, defining every room, monster, item, spell, and interactive event in the game world. I also had a gameplay capture from 1996, the original GM scripting manual from 1998, and assorted player documentation. What I did not have was the game engine source code.

Here’s what happened next: I pointed Claude Code at the artifacts and said, essentially, figure out what this game was and rebuild it. That makes it sound simpler than it was—I spent the weekend in a tight loop with the agent, providing context, shaping decisions, course-correcting when its assumptions drifted, and making the technical judgment calls that no AI can make on its own. Agentic coding isn’t autopilot. It’s more like directing a tireless, brilliant collaborator who needs you to stay in the room.

The results were startling. Even without source code, the ability to observe the outputs and interactions from the original game were sufficient for reconstructing the core experience. Claude Code reverse-engineered my scripting language—parsing the DOS-era script files, decoding the combat formulas from GM documentation, and inferring the behavioral patterns of monsters from strategy fields that encoded AI profiles as integer ranges. It built a complete game engine in Go, a React frontend, a WebSocket multiplayer layer, and a MongoDB persistence system. The whole thing deployed to Fly.io.

A game that I originally coded over six months—with a whole team of Game Masters building the content over years—was resurrected in a weekend of agentic coding.

Reverse-Engineering a Language I Barely Remember

When I looked at the script file language I invented when I was nineteen, it was a little humbling. It’s a pretty bad language. My only excuse is that I had to make an entire game world fit into a 16MB Pentium machine, and although I’d written games and a BBS before this, I’d never written a language before.

The scripting system used an imperative syntax with conditional blocks—IFVERB, IFVAR, IFITEM, IFPREVERB, ELSE, ENDIF—and supported variable arithmetic, monster spawning, item creation, room transitions, and dozens of other actions. It was case-insensitive, DOS-encoded, and full of the kinds of shortcuts you make when you’re nineteen and optimizing for memory constraints that no longer exist.

That said, it worked. Relatively non-technical people of the time learned to use it—our Game Masters would write elaborate interactive storylines, puzzles, and events using this language. And Claude Code had no problem reverse-engineering the language interpreter from the code examples and manuals. It parsed the conditional logic, decoded the noun and adjective definition systems, figured out how room descriptions were delimited, and reconstructed the entire execution model for script triggers—entry scripts, verb scripts, pre-verb validation, speech handlers, all of it.

This is the part that still amazes me. A language I designed three decades ago, with no formal specification beyond a GM manual and a pile of example scripts, was fully reconstructed by an AI agent that had never seen it before.

The Software Archaeology

Vernor Vinge called it the work of the “programmer-archaeologist”—in A Deepness in the Sky, he imagined a far future where the most valuable skill wasn’t writing new code, but excavating ancient programs from vast, layered codebases and making them work again. The concept of software archaeology has become a real discipline, but Vinge’s fiction captured something that felt very literal to me this weekend.

For those interested in how the sausage gets made, here’s what the reconstruction involved at a technical level.

The contrast between the original and modern tech stacks tells its own story. In the 1990s, the game was written in C, running on Major BBS as a single-instance process with fully reentrant code—everything had to fit on a 16MB Pentium, persisting data to a Novell Network with a b-tree file store. The resurrected version runs on Go with goroutines handling concurrency—a multiplayer game is essentially a system of concurrent state machines, and Go handles that elegantly. The frontend is React with TypeScript, connecting over WebSockets for real-time gameplay. MongoDB handles persistence: player characters, session recordings, game logs, and a hub system for multi-machine synchronization using change streams. Two different eras of engineering philosophy, same game.

The script parser had to solve some genuinely tricky problems. The original files were DOS-encoded with case-insensitive filenames, which immediately broke on case-sensitive filesystems. Script blocks could be implicitly terminated—a pattern that required the parser to infer structure rather than just follow explicit delimiters. Variables lived in multiple namespaces (player stats, item properties, environmental data) and had to be resolved contextually at runtime.

The combat system was reverse-engineered from the 1998 GM manual: d100 threshold mechanics with damage severity tiers ranging from “Puny” to “Dazzling,” weapon-dependent attack verbs, stance modifiers (offensive, defensive, berserk), fatigue accumulation, weather effects on accuracy, elemental criticals, and an armor reduction system capped at 85%. The monster AI was decoded from STRATEGY fields—integer ranges that mapped to behavioral profiles from non-hostile to fight-to-the-death.

All told, the reconstructed game includes 2,273 rooms, 1,990 items, 297 monster types, 88 spells across five schools of magic, 30 psionic disciplines, a full crafting pipeline (mining, smelting, forging, alchemy, weaving), 8 playable races, and a 12-month in-game calendar. The original game, faithfully rebuilt.

What This Means for the Direct-From-Imagination Era

I’ve written before about the direct-from-imagination era—the idea that we’re entering a period where the bottleneck for creation shifts from technical implementation to imagination itself. This project is maybe the most personal proof point I have for that thesis.

In the 1990s, building Legends of Future Past required months of solo effort just for the engine, plus a whole team of Game Masters building the world over years: writing a custom game engine in C, inventing a scripting language, hand-coding thousands of rooms and items, managing server infrastructure on hardware that cost more than a car. The technical barriers were enormous. Most of what we spent our time on wasn’t creative—it was engineering.

What happened this weekend inverts that equation. The engineering was handled by an AI agent. My job was to provide the creative artifacts—the scripts, the documentation, the vision of what the game was supposed to be—and to make judgment calls the agent couldn’t make on its own. The imagination was the input. The implementation was automated.

This isn’t just about nostalgia or game preservation, though I think both of those matter. It’s about what becomes possible when the cost of implementation approaches zero. How many dead online worlds could be resurrected if all you needed were the creative artifacts and a weekend? How many games that only existed in someone’s imagination could now become real?

I’ve also written about games as platforms rather than just products—and about the age of machine societies, where bots and AI agents become participants in virtual worlds rather than just tools for building them. Bots weren’t part of the original 1990s game, of course. But Legends of Future Past now has a bot API: you can generate per-character API keys and connect automated agents that participate in the game world alongside human players, following the same rules, inhabiting the same spaces. A bot can’t do anything a human can’t. And maybe that’s exactly the point—Andor gets to live on as a place to breed and experiment with machine societies. A game built in 1992, resurrected by AI in 2026, might find its deepest new meaning as a world where humans and agents coexist.

Come Visit Andor

The game is live at lofp.metavert.io and the source code is open under the MIT license on GitHub. You can create a character, explore the Shattered Realms of Andor, and experience a piece of gaming history that nearly vanished forever.

If you were one of the thousands who played the original game in the 1990s—some of you are still out there, I know—come home. The world remembers you, even if the servers forgot.

And if you never played it, you’re welcome too. The rooms are still there, the monsters still wander, and the stories are waiting to be told again. This time, they won’t disappear.

Subscribe now

“There were programs here that had been written five thousand years ago, before Humankind ever left Earth. The wonder of it—the horror of it, Sura said—was that unlike the useless wrecks of Canberra’s past, these programs still worked!”

— Vernor Vinge, A Deepness in the Sky

Further Reading

The Direct-From-Imagination Era Has Begun — How AI is shifting the bottleneck from implementation to imagination.

Games as Products, Games as Platforms — Why the future of games lies in composability, not just content.

The Age of Machine Societies Has Arrived — What happens when bots become participants, not just tools.

Software’s Creator Era Has Arrived — The broader shift that makes projects like this possible.

Game Player Motivations — Extending Bartle’s taxonomy for the modern era of play.

Vernor Vinge — The science fiction visionary who imagined programmer-archaeologists.

87% Missing: The Disappearance of Classic Video Games — The Video Game History Foundation’s study on game preservation.

Raph Koster’s Online World Timeline — A comprehensive history of virtual worlds from MUD1 to the metaverse.

This isn’t a provocation for its own sake. It’s a description of reality in March 2026.

LinkedIn just replaced its Associate Product Manager program with “Associate Product Builder,” a role that combines code, design, and product management into a single function. Microsoft and Citi are creating dedicated “agent ops” teams to manage fleets of AI agents. And according to recent developer surveys, 41% of all code committed to production is now AI-generated, with 92% of US developers using AI coding tools daily.

Something fundamental has shifted. Not in the tools we use, but in the velocity at which strategy can become product. And that shift is rewriting what it means to be a product manager. The PM role isn’t dying; it’s expanding into something I call the Full-Stack Product Manager: a product leader who doesn’t just coordinate between strategy and engineering, but operates fluidly across both, using AI agents as force multipliers across the entire product lifecycle.

This isn’t about adding AI features to your product. It isn’t about hiring a prompt engineer or bolting a copilot onto your existing workflow. It’s about recognizing that the entire loop—from strategic insight to shipped product to market feedback—can now collapse from quarters into days.

The product leaders who understand this will define the next era. The ones who don’t will spend the next year perfecting a strategy deck for a product that someone else already shipped.

Subscribe now

The $285 Billion Wake-Up Call

In February 2026, the software industry lost $285 billion in market value. Most analysts called it a correction. It wasn’t. It was structural.

The SaaS model—built on per-seat licensing, integration complexity as a moat, and incremental feature development—is being unwound by a simple reality: AI agents don’t need seats. They don’t need onboarding. And they increasingly don’t need the software at all.

The threat to Asana isn’t that AI makes Asana easier to use. The threat is that an AI agent can manage your project without Asana. The threat to Salesforce isn’t a better copilot. It’s that an agent can orchestrate your entire sales pipeline by composing smaller, cheaper primitives; CRM becomes an implementation detail, not a product category.

This is what I’ve described elsewhere as the shift from the Engineering Era to the Creator Era. Language models have become compilers for natural language, translating intent into implementation the way Fortran once translated mathematics into machine code.¹ The winners aren’t the companies with the best features. They’re the ones who understand that entire categories of software are being absorbed into agent workflows — and are positioning accordingly.

Naval Ravikant observed that “vibe coding is the new product management.” He was right about the direction but underestimated the magnitude. Vibe coding doesn’t replace product management. It subsumes it, absorbing specification, prototyping, testing, and initial deployment into a single fluid workflow that one person with the right strategic instincts can drive.

The companies that are winning right now—Cursor hitting $1 billion ARR in 24 months, Lovable reaching $20M ARR with explosive growth among non-technical founders—aren’t just AI-enhanced versions of older tools. They’re built on the assumption that the distance between “I want to build this” and “this is running in production” is measured in hours, not quarters.

Which raises the question: if strategy can be shipped, and products can be prototyped in hours instead of months, what does product leadership actually look like?

The Full-Stack Product Manager

The traditional product manager coordinates. They write PRDs, align stakeholders, prioritize backlogs, and hand specifications to engineering. In the agentic era, that workflow is a bottleneck.

The full-stack PM doesn’t just manage the product process; they operate within it.

They prototype strategy directly. They deploy agents to gather competitive intelligence autonomously. They build feedback systems that cycle user insights into shipped features in hours, not sprints. And they treat AI-driven discoverability as a first-class product concern, not a marketing afterthought.

This isn’t about one person doing everything. It’s about the PM role expanding to absorb capabilities that used to live in separate functions — and, crucially, about software engineers with strong product instincts moving into this expanded role. When the distance between “I think we should build this” and “here’s a working prototype” collapses to a conversation with an agent, the line between product management and product development dissolves. The full-stack PM lives in that dissolved space.

The framework has four pillars:

1. Ship: Prototype your strategy, don’t just present it

2. Discovery: Build for AI-native visibility from day one

3. Compete: Deploy agents for continuous competitive intelligence

4. Iterate: Collapse the feedback-to-action loop from sprints to hours

Each of these represents a fundamental departure from how product organizations have operated for the past two decades, and from the frameworks those organizations were built on.

Consider how the canonical PM playbooks transform under this model. Eric Ries’s Build-Measure-Learn loop doesn’t disappear. It accelerates from weeks to hours. When agents can prototype a feature in an afternoon and instrument it for real user data by evening, you’re not running one lean experiment per sprint. You’re running dozens per week. The constraint shifts from cycle time to judgment: which experiments are worth running?

Jobs to Be Done: Clayton Christensen’s framework for understanding what customers actually hire your product to accomplish evolves from periodic qualitative research to continuous signal detection. Instead of 10-20 customer interviews per quarter, agents can monitor thousands of support tickets, community conversations, and behavioral patterns to surface emerging jobs in real time. The human PM’s role shifts from “conduct the interviews” to “decide which discovered jobs matter strategically.”

And Teresa Torres’s Continuous Discovery: structured, frequent conversations with users to identify problems worth solving—transforms from a cadence (weekly interviews) into a continuous information flow. Agents conduct hundreds of conversations; humans synthesize patterns and decide which insights warrant exploration.

The frameworks aren’t obsolete. They’re unshackled from human bandwidth. The full-stack PM doesn’t abandon these tools — they run them at machine speed, reserving human judgment for the decisions that actually require it.

Pillar 1: Ship Your Strategy

Garry Tan, Y Combinator’s CEO, has been vocal about the progression people go through with “vibe coding,” from not using AI at all to increasingly sophisticated collaboration with AI agents. His own toolkit, gstack structures Claude Code workflows with specialized roles (CEO, Designer, Eng Manager, QA) to manage complex projects.

But here’s what most people miss: the progression doesn’t stop at “good at vibe coding.” Most practitioners plateau around he called Level 3 or 4: they can prompt effectively, they accept diffs without reading every line (the original Karpathy definition²), and they ship small projects faster than before. That’s table stakes now.

The levels beyond that are where the real transformation happens. Level 5 is directing agents across entire architectures: not just writing code, but designing systems through conversation. Level 6 is running multiple agent-built projects concurrently, maintaining strategic coherence across them. Level 7 is building agent-native infrastructure; products whose architecture assumes AI agents will extend, maintain, and operate them. And Level 8 is the full-stack PM: orchestrating the full product lifecycle, from competitive intelligence through shipping through discovery, with agents as the primary execution layer and human judgment as the strategic spine.

At this level, the person directing the agents isn’t just coding faster. They’re operating at the product level, coordinating multiple agent-built systems simultaneously, cycling between strategy and implementation fluidly, and maintaining coherence across a portfolio of rapid-fire projects.

This is where traditional tooling breaks down catastrophically. Jira doesn’t understand agentic workflows. Linear doesn’t know your agent’s context window is finite. GitHub Issues doesn’t grasp that your “engineering team” is you and three Claude sessions running in parallel. Traditional PM tools were built for human-to-human coordination patterns: sprint planning, standup notes, story points. None of that maps to a workflow where your primary constraint is context management across multiple AI sessions, and where “sprint velocity” is measured in shipped features per day rather than story points per two-week cycle.

The tooling gap between “vibe coding one project” and “orchestrating an agent-powered product organization” is enormous — and it’s a gap that reveals something important about where product leadership is headed.

I hit this wall myself when I was running six agent-built projects simultaneously. No project management tool understood the constraints: finite context windows, multi-agent coordination, the pace at which decisions needed to be made and tracked. So I built VibeCtl—a command-and-control system designed specifically for the agentic development workflow. It uses a VIBECTL.md file as a single source of truth that both humans and agents can read, integrates directly via MCP (Model Context Protocol) so agents never leave their coding environment, and tracks health, feedback, and deployment across projects that move at the speed of thought.

The point isn’t the specific tool. The point is the principle: if your strategy can’t become a working prototype in a weekend, you need to ask whether it’s actually a strategy or just a hope.

Consider what this looks like in practice. Chessmata (a multiplayer chess platform where humans and AI agents compete on equal footing) was built in a weekend using what I call “English-only programming.” The backend is Go with WebSocket multiplayer. The frontend is React with Three.js 3D rendering. It has Elo-based matchmaking, MCP integration for agent players, and a reference AI (Maia-2) that plays like a human at any skill level. Not a prototype. A production system.

Or take LastSaaS: a complete, production-ready SaaS boilerplate with multi-tenant architecture, Stripe billing, RBAC, OAuth, webhooks, API keys, product analytics, and 26 MCP admin tools. Built entirely through conversation with Claude Code by one person. It’s not notable because it exists — SaaS boilerplates have existed for years. It’s notable because the codebase was designed for AI-assisted extension: consistent patterns, clear naming conventions, agent-navigable structure. The product architecture itself assumes agents will continue building it.

The “Ship Your Strategy” principle isn’t about moving fast and breaking things. It’s about closing the gap between insight and evidence. When you can prototype a strategic hypothesis in days rather than months, you’re not just faster—you’re operating on a fundamentally different learning curve. You have real user data while your competitor is still getting stakeholder buy-in on a Figma mock.

The 10x PM is now the 100x PM. Not because the individual works harder, but because the loop between “I think this might work” and “let’s see if it actually works” has collapsed from a quarter to a weekend.

Pillar 2, Discover: Build for the AI-Native Web

Here’s a statistic that should reframe how every product leader thinks about go-to-market: according to recent GEO research, roughly 80% of URLs cited by major LLMs don’t appear in Google’s top 100 results for the same queries.³

Read that again. The content that AI systems recommend to users has almost no correlation with traditional search rankings. LLM citation signals correlate only 12-18% with traditional SEO. And this matters enormously, because 58% of consumers now rely on AI for product recommendations—up from roughly 29% just two years ago.

Gartner forecasts a 25% drop in traditional search traffic by end of 2026. Google’s own growth has been visibly dampened by ChatGPT and other AI interfaces. Younger generations already treat Google as a backup, not a first stop. The entire discovery layer of the internet is being restructured—and most product organizations haven’t even started adapting.

I’ve spent significant time researching this shift, and the data is stark. What I’ve found—and documented in depth in my piece on LLM optimization and marketing in the age of AI discovery — is that AI-native discoverability requires a fundamentally different playbook:

Quotability dominates. Adding authoritative, quotable statements to your content increases LLM citation rates by 41%. AI systems are looking for definitive, citable claims—not keyword-optimized filler. Structure your product content as if every paragraph might be quoted by an AI recommending solutions to a user.

Earned media outweighs owned content. Between 72% and 92% of LLM citations come from reviews, forums, Reddit threads, and independent articles — not from brand-owned websites. Only 18-27% of citations come from your own site. This means your “content marketing strategy” needs to prioritize how others talk about you, not just what you say about yourself.

Freshness crushes authority. Content freshness can shift an LLM’s recommendations by 95 positions. The decades-old SEO wisdom that domain authority compounds over time is being disrupted by AI systems that heavily weight recency.

Cross-provider variation is extreme. Citation concentration varies between 28% and 67% across different AI systems, with content similarity scores between 0.11 and 0.58. What Claude recommends and what ChatGPT recommends are often wildly different. You can’t optimize for one model and assume coverage.

Video is critical. YouTube content appears in 16% of all LLM answers. If your product strategy doesn’t include a video authority component, you’re invisible to a significant slice of AI-driven discovery.

The implication for product leaders is profound: discoverability isn’t a marketing function anymore. It’s a product architecture decision. If your APIs aren’t structured for agentic consumption, if your documentation isn’t optimized for LLM parsing, if your content strategy doesn’t account for how AI systems select and cite sources—your product is structurally disadvantaged in the discovery layer.

I’ve built LLM Optimizer — an open-source tool that analyzes how AI systems perceive and recommend brands across Claude, ChatGPT, Gemini, and Grok — specifically because I realized there was no instrumentation for this new reality. It measures Answer Engine Optimization, Video Authority, Reddit Authority, Search Visibility, and direct LLM Knowledge Testing to produce a composite AI Visibility Score. Think of it as the “Google Search Console” equivalent for the AI-native web.

But the broader strategic point transcends any single tool: the full-stack PM treats AI discoverability as a core product metric, right alongside activation rates and retention curves. Because in a world where AI agents increasingly mediate how users find and evaluate software, being invisible to those agents is existential.

I explored this theme from the other direction when I built an agent that discovers other agents — a self-improving directory system where AI agents autonomously catalog tools, MCP servers, and workflows. The most striking finding: most of the internet is not designed for agentic consumption. Marketing pages optimized for human eyes resist programmatic parsing. Companies without agent-friendly documentation — clean JSON APIs, structured metadata, semantic markup — are invisible to the autonomous discovery mechanisms that will increasingly drive software adoption.

The product leaders who build for AI-native discovery now will have a compounding advantage. Those who wait will find themselves optimizing for a distribution channel — traditional search — that is structurally declining.

Pillar 3, Compete: Deploy Agents as Your Intelligence Network

Most competitive intelligence in product organizations is still artisanal. Someone on the team monitors competitors’ blogs. Maybe there’s a quarterly battlecard refresh. Pricing changes get noticed weeks after they happen, usually because a sales rep lost a deal.

This is absurd in 2026. We have access to autonomous reasoning systems that can monitor thousands of channels simultaneously, distinguish signal from noise, and synthesize findings into actionable intelligence in real time. Yet most product teams still treat competitive intelligence as a periodic human effort.

The full-stack PM deploys agents as a continuous intelligence network:

Competitive monitoring. Agents that track competitor product launches, pricing changes, positioning shifts, and hiring patterns across their websites, job boards, GitHub repos, social media, and community forums — and surface only the signals that warrant strategic attention. Not a dashboard you check weekly. A system that interrupts you when something matters.

Pricing intelligence. Agents that model competitive pricing dynamics and recommend positioning adjustments. The tools emerging in this space — platforms like Klue and Crayon — are evolving toward agentic architectures where the system doesn’t just collect data but reasons about strategic implications.

Market signal synthesis. Agents that aggregate customer feedback from support tickets, community forums, social media, and review sites — then triangulate patterns against competitive movements to identify emerging opportunities or threats. When a competitor’s users start complaining about the same issue on three different platforms simultaneously, your agent should know about it before their product team does.

Research acceleration. I built Paper Scout to automate academic research monitoring; it tracks arXiv, Semantic Scholar, and Hugging Face daily, scores papers against my interest profile using local embeddings, and surfaces findings through MCP tools in Claude. The principle applies broadly: any knowledge domain relevant to your product strategy can be monitored by agents that handle volume and speed, leaving human judgment for assessment and strategic interpretation.

The shift isn’t from “humans do competitive intel” to “agents do competitive intel.” It’s from episodic, reactive analysis to continuous, proactive intelligence — with humans focusing on the judgment calls that agents surface, rather than the data gathering that precedes them.

Here’s where this connects back to the broader thesis: the same agentic infrastructure that lets you ship faster also lets you see faster. When your competitive intelligence loop runs continuously rather than quarterly, you can respond to market shifts in days rather than months. Combined with the ability to prototype and ship in weekends, the entire strategic cycle compresses dramatically.

The competitive advantage doesn’t go to the company with the best strategy. It goes to the company that can cycle through the strategy-to-evidence loop fastest.

There’s a deeper pattern here worth naming. In my analysis of enshittification and the future of AI agents, I’ve argued that the current fragmentation of platforms—Slack, Discord, WhatsApp, each a silo designed to prevent interoperability—creates a structural opportunity for agents. Agents can float above fragmented platforms, orchestrating intelligence gathering across channels that were never designed to interoperate. Your competitive intelligence agent doesn’t care that your competitor’s community is on Discord while their support forum is on Zendesk and their hiring is on LinkedIn. It operates at the semantic layer, extracting signal from wherever it exists.

This is also why the full-stack PM’s competitive intelligence function naturally extends into positioning and pricing strategy. When your agents are continuously monitoring how competitors frame themselves, how their users respond, and how AI systems describe the competitive landscape, you have the raw material to dynamically adjust your own positioning — not in quarterly strategy reviews, but in real time.

Pillar 4, Iterate: Collapse the Feedback Loop

The conventional product feedback loop looks something like this: users report issues through support channels, which get triaged into a backlog, which gets prioritized in a sprint planning meeting, which leads to engineering work, which ships in the next release cycle. Best case, six weeks from feedback to fix. Typical case, three to six months.

In the agentic era, this is inexcusably slow.

This pillar demands feedback systems where user inputs flow directly into the development loop with minimal human friction. Not by removing human judgment, but by automating everything around the judgment:

Automated feedback triage. User reports — from support tickets, community forums, in-app feedback widgets — are processed by AI that categorizes, deduplicates, identifies patterns, and converts raw user language into structured issues with severity assessments and reproduction steps. The human role shifts from “process the firehose” to “validate the filtered signal and decide on priority.”

Rapid prototyping of fixes. When a critical feedback pattern emerges, an agent can prototype the fix — not just write the code, but create a working branch, run tests, and present the human with a reviewable solution. The product lead’s job isn’t to spec the fix and wait for engineering. It’s to evaluate whether the fix aligns with the broader product direction and approve it.

Continuous deployment as default. When the feedback-to-fix loop runs in hours rather than sprints, gated release cycles become the bottleneck. The agentic product organization deploys continuously, with agents monitoring production health and rolling back automatically if issues emerge.

Evidence-driven prioritization. Instead of quarterly planning sessions where prioritization is driven by stakeholder opinions and HiPPO dynamics,⁴ the feedback loop generates continuous quantitative evidence about what users actually need — triangulated across support data, behavioral analytics, competitive intelligence, and market signals. The PM’s role isn’t to collect this data manually. It’s to build the agentic systems that synthesize it and surface the priorities that matter.

Qualitative feedback at scale. One of the most influential pieces in product management history is Rahul Vohra’s account of how Superhuman built an engine to find product-market fit. The quantitative piece was elegant: ask users “How would you feel if you could no longer use this product?”, track the percentage who say “very disappointed,” and aim for 40%. Superhuman went from 22% to 58% using this method. But the hard part was always the qualitative layer—understanding why users felt that way, segmenting by persona, mining the “somewhat disappointed” cohort for convertible users, and synthesizing open-ended responses into actionable product direction. That qualitative synthesis used to take weeks of manual coding and analysis. Today, an agent can process thousands of qualitative survey responses in minutes: clustering themes, identifying persona patterns, cross-referencing against behavioral data, and surfacing the exact friction points that separate “somewhat disappointed” from “very disappointed” users. The Superhuman methodology hasn’t changed—the 40% threshold, the focus on high-expectation customers, the 50/50 roadmap split between “double down on love” and “address barriers”—but the speed at which you can run the entire engine has collapsed from quarters to days.

Product-market fit is no longer something you measure periodically. It’s something you instrument continuously.

The compound effect of collapsing all four loops—shipping, discovery, competitive intelligence, and iteration—is that the entire product organization operates on a fundamentally different clock speed. Not “agile” in the two-week-sprint sense. Agile in the this-afternoon sense.

To make this concrete: the feedback triage system in VibeCtl uses Claude to automatically convert user reports into structured issues — categorized, severity-assessed, and linked to the relevant project context. A user submits a bug report in natural language; the agent parses it, checks it against known issues, generates reproduction steps, and presents it to me as a decision: fix now, defer, or investigate further. If I choose to fix, an agent can have a working branch with tests within the hour. That’s not a theoretical workflow. That’s Tuesday.

The old model—support team triages, PM prioritizes, engineering estimates, sprint planning allocates—was designed for a world where implementation was the bottleneck. When implementation takes hours instead of weeks, the bottleneck shifts to decision quality and speed. The full-stack PM optimizes for that bottleneck, not the old one.

The Governance Imperative

Speed without governance is recklessness. And this is where I part ways with much of the current discourse around agentic product development.

The data is sobering: AI co-authored code contains 1.7 times more major issues than human-written code and 2.74 times more security vulnerabilities.⁵ Sixty-three percent of developers report spending more time debugging AI-generated code than it would take to write it from scratch. And fewer than 10% of enterprises running production agents can govern them effectively.

The responsible builder doesn’t ignore these realities. They build governance into the system from the start:

Provenance and audit trails. Every agent action—every code commit, every competitive intelligence finding, every feedback triage decision—is logged with full chain of custody. Not for compliance theater, but because when you’re operating at agentic speed, the ability to understand why a decision was made and who (human or agent) made it becomes critical for debugging both code and strategy.

Constitutional guardrails. Hard constraints that agents cannot cross, regardless of what they optimize for. These aren’t just ethical boundaries (though those matter too). They’re product strategy boundaries: pricing floors the competitive intelligence agent can’t recommend below, user data the feedback triage agent can’t access without human approval, deployment environments the CI/CD agent can’t push to without review.

Human-in-the-loop architecture. The critical design decision is where agents handle volume and speed versus where humans retain judgment and approval. The art is knowing where those decision points are, and that knowledge comes from deep product experience, not from prompting techniques.

Recent research from Wharton makes the stakes of this design decision disturbingly concrete. Shaw and Nave’s “Thinking — Fast, Slow, and Artificial” extends Kahneman’s dual-process model by identifying a third cognitive system: System 3, the AI layer that increasingly mediates human decision-making.⁶ Their key finding is what they call cognitive surrender—the tendency to adopt AI outputs without critical scrutiny. Across three studies with 1,372 participants, they found that when AI provided correct guidance, accuracy jumped by 25 percentage points. But when AI was wrong, accuracy dropped by 15 points—and critically, participants’ confidence in their answers remained inflated regardless. People didn’t just follow bad AI advice. They believed they’d arrived at the answer independently.

The effect size (Cohen’s h = 0.81) is large enough to matter at the product level. And the finding that people with lower “need for cognition”—those who prefer intuitive over analytical thinking—surrender more readily has direct implications for how product teams interact with agentic tools. The full-stack PM’s governance architecture isn’t just about catching agent errors. It’s about designing workflows that structurally resist cognitive surrender — ensuring that human review points are genuine decision gates, not rubber stamps on AI recommendations.

The agent error compounding problem illustrates why this matters at scale: if you chain 20 steps, each 95% reliable, your end-to-end success rate is only 36%. Knowing which steps can be fully automated, which need human checkpoints, and how to structure the overall workflow so that errors are caught before they compound — that’s the governance dimension of the full-stack PM’s role. Shaw and Nave’s research suggests the compounding isn’t just technical — it’s cognitive. Each time a human “reviews” agent output without genuine scrutiny, the probability of catching downstream errors degrades further.

The Machine Societies Are Already Here (And They Change All Four Pillars)

One dimension of this transformation that gets insufficient attention — and that compounds across all four pillars — is that agents don’t just work for you. They increasingly interact with each other.

I’ve tracked this extensively in my research on the age of machine societies. There are now 17,000+ MCP servers enabling agent-to-agent communication. Platforms like Moltbook have hosted 770,000+ agents autonomously posting, voting, and coordinating. Google’s Werewolf Arena has revealed that different AI models have distinct strategic signatures — GPT-4’s verbosity becomes a tell, while Gemini’s casual style reads as more authentic in deception scenarios.

For product strategy, the implications are significant:

Agent-to-agent marketplaces are emerging. Your product doesn’t just need to be discoverable by humans. It needs to be consumable by other agents. MCP integration, clean API design, and structured metadata aren’t nice-to-haves — they’re the equivalent of having a website in 2005.

Network effects follow Reed’s Law. When agents can easily form subgroups and collaborate, value grows not as n (Metcalfe’s Law) but as 2^n (Reed’s Law).⁷ Products that facilitate agent-to-agent connections will generate exponentially more value than those designed purely for human users.

Security becomes a product feature. In a world of autonomous agent interaction, prompt injection attacks, malicious plugins, and coordinated agent manipulation are real threats. Products with robust agent governance will command premium positioning — security becomes a differentiator, not a cost center.

In my market map of the agentic economy, I identified seven layers — from physical infrastructure (silicon, energy) up through compute, knowledge substrate, foundation models, platforms, creation and orchestration tools, to the agent experience layer at the top. The full-stack PM needs to understand where their product sits in this stack, because the dynamics at each layer are radically different. At Layer 7, ASML’s $350 million EUV lithography machines are the only equipment on Earth capable of printing the chips agents run on. At Layer 6, Big Tech has committed over $700 billion in AI capex for 2026 alone. At Layer 2, MCP has crossed 10,000 active servers with 97 million monthly SDK downloads. And at Layer 1, 58% of consumers now rely on AI for product recommendations—with 93% of those sessions ending without a single click to a website. The products that invest in being MCP-native and agent-consumable today are building the equivalent of early web standards compliance: boring infrastructure work that compounds into decisive strategic advantage. Every new tool connected to the network makes every agent more capable, and every new agent makes every tool more valuable—classic Reed’s Law dynamics playing out in real time.

What This Means for You

If you’re a startup founder: the window for building AI-native is right now. Not “AI-enhanced” — truly native, where agents are first-class participants in your product architecture from day one. The SaaS companies losing market cap are the ones who treated AI as a feature. The ones gaining ground are the ones who treated it as an architecture.

If you’re a product leader at scale: the organizational shift is harder than the technical one. You need product people who can prototype, not just spec. You need feedback systems that run in hours, not sprints. You need competitive intelligence that’s continuous, not quarterly. And you need to accept that the PM role as you’ve known it —the coordinator, the spec writer, the stakeholder aligner—is being absorbed into something more integrated and more powerful.

If you’re a technical PM or builder—or a software engineer with product instincts: you’re already closer to this than you think. The skills that matter in the agentic era aren’t new. They’re product judgment—knowing what to build, for whom, and why—combined with the ability to actually build it, rapidly, using agents as force multipliers. The full-stack PM doesn’t replace product thinking with engineering. They unify them. And that convergence runs both directions: PMs who can prototype are leveling up, and engineers who understand users and markets are becoming the PMs. The 25-40% salary premium that agentic PM roles command over generalist PMs right now isn’t about prompt engineering skill—it’s about this integration of strategic judgment and execution capability.

The emergence of formal “Agentic Product Manager” roles at Microsoft, Citi, and IFS signals that the market recognizes this shift. But the role title is less important than the capability: can you go from strategic hypothesis to shipped evidence in days? Can you instrument your product for AI-native discovery? Can you deploy agents that make your competitive intelligence continuous rather than episodic? Can you build feedback loops that run at the speed of your agents, not the speed of your sprint calendar?

The four pillars—Ship, Discover, Compete, Iterate—aren’t sequential. They’re concurrent loops, all running simultaneously, all powered by agents, all accelerating each other. The product leader who can orchestrate all four is operating at a velocity that traditional product organizations simply cannot match.

The Bottleneck Has Moved

For decades, the bottleneck in product development was engineering capacity. Could we build it? How many engineers do we need? What’s the timeline?

That bottleneck has moved. Inference costs have fallen 92%—from $30 to under $2.50 per million tokens. Claude Opus 4.6 exceeds human experts on PhD-level reasoning. Autonomous task horizons are doubling every 123 days. Four percent of GitHub commits are already made by Claude Code, projected to exceed 20% by year-end. Eighty percent of databases on Neon are created by AI agents.

The new bottleneck is imagination. It’s knowing what to build and why — and having the strategic judgment to navigate a world where shipping is cheap but attention is expensive, where agents can build anything but governance determines what they should build, and where the discovery layer that connects products to users is being rebuilt in real time.

That’s the job of the full-stack product manager. Not a new title—an expanded one. The same strategic judgment that always defined great PMs, now extended across the full product lifecycle by agents that make one person’s vision operationally viable at a scale that used to require an entire organization.

The strategy deck era is over. Ship your strategy. Let the evidence do the talking.

The tools are here. The cost curves have crossed. The only question left is whether you’ll be the one shipping—or the one watching your roadmap get built by someone who moved faster.

Subscribe now

Further Reading

My previous work on the frameworks behind this piece:

• Market Map of the Agentic Economy — the seven-layer value chain from silicon to agents, with competitive positioning analysis of every major player

• LLM Optimizer: Marketing in the Age of AI Discovery — deep dive into how LLM citation signals diverge from traditional SEO, and what product teams need to do about it

• Software’s Creator Era Has Arrived — the thesis that language models are compilers for natural language, and what that means for who can build software

• How Superhuman Built an Engine to Find Product-Market Fit (First Round Review) — the foundational product-market fit methodology referenced in Pillar 4, and still the best framework for systematic PMF measurement

• Practical Guide to Controlled Experiments on the Web: Listen to Your Customers not to the HiPPO (Kohavi et al., KDD 2007) — the paper that formalized the case against gut-feel product decisions; now assigned reading at Stanford

• GEO: Generative Engine Optimization (Aggarwal et al., 2024) — the academic research behind the discovery shift, showing how LLM citation signals diverge from traditional search

• The Spotify Model: Why It Failed and What AI Changes — how autonomous squads evolve when AI agents handle coordination complexity

• Thinking — Fast, Slow, and Artificial: A Tri-System Theory of Cognition (Shaw & Nave, Wharton 2025) — the research behind “cognitive surrender” and why human-in-the-loop governance requires structural design, not just good intentions

• Why LinkedIn Is Replacing PMs with AI-Powered “Full-Stack Builders” (Lenny Rachitsky, Dec 2025), on how LinkedIn CPO Tomer Cohen is scrapping the APM program, creating the Associate Product Builder role, and building a Full Stack Builder career ladder

If you’re navigating this transition — whether you’re rethinking your product org, building AI-native for the first time, or figuring out how agents fit into your competitive strategy — I’d love to hear what’s working and what isn’t. The best conversations I’ve had on this have been with people who are building, not just theorizing. Reach out, reply here, or find me on LinkedIn or X.

Footnotes

1. When Grace Hopper built the first compiler in 1952, she later recalled that “nobody believed that,” because the prevailing wisdom was that computers could only do arithmetic, not write programs. Her colleagues told her a computer couldn’t write code because “it doesn’t understand English.” Seventy-four years later, we’re having the same argument in reverse — except now the computer does understand English, and the resistance comes from people who insist that understanding English isn’t the same as understanding software. They’re right, technically. But Hopper was right, practically. The compiler won. ↩

2. Andrej Karpathy coined “vibe coding” in a February 2025 tweet describing a new mode of programming where “you fully give in to the vibes, embrace exponentials, and forget that the code even exists.” He described accepting diffs without reviewing them, running code to see if it “vibes right,” and relying on the LLM to fix errors when something breaks. The term went viral because it named something developers were already doing but felt mildly guilty about. ↩

3. Based on findings from Aggarwal et al., “GEO: Generative Engine Optimization” (2024), combined with subsequent cross-provider citation analyses by BrightEdge (2025) and the NanoKnow benchmark for measuring factual accuracy across LLM providers. The 80% figure represents aggregate findings across ChatGPT, Perplexity, Gemini, and Claude when tested against equivalent Google Search queries. ↩

4. HiPPO, the “Highest Paid Person’s Opinion,” was coined by Dylan Lewis at Intuit around 2006 and popularized by Ronny Kohavi’s Experimentation Platform team at Microsoft, who distributed thousands of toy hippos across the company as a cultural intervention against gut-feel product decisions. (Kohavi’s 2007 KDD paper, “Practical Guide to Controlled Experiments on the Web: Listen to Your Customers not to the HiPPO,” is now assigned reading at Stanford and the University of Washington.) The data on HiPPO’s costs is striking: an Oracle study of 14,000 employees across 17 countries found that 74% believe their organizations routinely put the highest-paid person’s opinion ahead of data, while Kahneman’s research shows that simple formulas and algorithms beat expert intuition at least 60% of the time across diverse domains. McKinsey found data-driven companies are 23x more likely to acquire customers. But the picture isn’t one-sided: Gary Klein’s Sources of Power research demonstrates that expert intuition genuinely outperforms data in domains with immediate feedback, regularity, and time pressure—firefighters, surgeons, chess masters. The catch for product orgs is that most product decisions fail all three of Klein’s conditions: feedback is delayed, markets are irregular, and there’s rarely genuine time pressure (just manufactured urgency). The HiPPO isn’t always wrong, but the conditions under which they’re reliably right are much narrower than most executives believe. ↩

5. GitClear’s 2025 code quality analysis of 211 million lines of changed code, corroborated by Snyk’s AI code security audit. The security vulnerability figure (2.74x) specifically measures CWE-classified vulnerabilities in code where AI tools were used versus code written entirely by humans. Interestingly, the gap narrows significantly when the developer has 10+ years of experience — suggesting the issue isn’t AI-generated code per se, but inexperienced developers using AI as a substitute for understanding rather than a supplement to it. ↩

6. Shaw, A. & Nave, G. (2025). “Thinking — Fast, Slow, and Artificial: A Tri-System Theory of Cognition.” Working paper, The Wharton School, University of Pennsylvania. The paper proposes extending Kahneman’s System 1/System 2 framework to include System 3 — artificial cognition mediated by AI. Their three studies (N=1,372) found that AI influence on decision-making was asymmetric: correct AI guidance improved accuracy dramatically, but incorrect guidance degraded it — while subjective confidence remained elevated in both cases. The practical implication for product teams is unsettling: the people most likely to rubber-stamp agent outputs are the ones who feel most confident they’re exercising independent judgment. ↩

7. David P. Reed proposed his law in 1999, arguing that the value of group-forming networks scales exponentially — but for decades it was considered mostly theoretical, since few networks actually enabled fluid subgroup formation. Social media partially validated it (Facebook Groups, Discord servers), but agents may be the first context where Reed’s Law fully applies: agents can form, dissolve, and reform working groups in seconds, with zero coordination overhead. If Reed was right, the most valuable AI products won’t be the smartest agents — they’ll be the ones that make it easiest for agents to find and work with each other. ↩

The result is Threelab: an open-source generative art platform built on React, Three.js and Go. It includes a visual node-graph editor, a genetic evolution system, and a full MCP server that lets AI agents create, mutate, breed, and export 3D visualizations without a human touching a slider.

Scenes export as standalone HTML files, React components, or raw JSON. No build step. Open the file in a browser and it runs. Embed it on a website and it just works. Composability — the principle I keep returning to — made real.

This post is partly a project introduction, partly a report from the frontier of agentic creative development, and partly a set of observations about where graphics, game engines, and AI-assisted creation are heading. Some of it is encouraging. Some of it is humbling. All of it points to something bigger than any single tool.

The Platform: Threelab in 60 Seconds

Threelab ships 21 built-in patterns spanning mathematical curves (Lissajous figures, strange attractors, L-system fractals), physics simulations (cloth, flow fields, wave interference), GPU shader programs (physarum slime molds, reaction-diffusion systems, Mandelbrot fractals), and procedural geometry (voxel landscapes, Voronoi tessellations, circle packing).

Every pattern is implemented as a wirable node graph. You can inspect the logic, fork it, rewrite the evaluate function in a syntax-highlighted code editor, and watch changes hot-reload in real time. Stack multiple patterns as layers with blend modes, opacity, and bloom post-processing. It’s a creative playground that happens to be a node-based visual programming environment underneath.

View the Threelab Slideshow

But here’s what makes it interesting for the conversation about agentic software: Threelab exposes 13 MCP tools and a full REST API. An AI agent can browse the gallery, create a new scene by assembling a genome of pattern layers and parameters, evolve it through mutation and crossover, rate the results, and export a standalone HTML file — all programmatically. The agent doesn’t need to understand WebGL or Three.js internals. It speaks in genomes and intentions. The platform handles the rendering. Think of the genome as a high-level language for generative art — the agent never writes WebGL code directly.

This is what I mean when I talk about the agentic web — software that’s designed from the ground up to be operated by AI, not just used by humans through a GUI. The MCP server is a first-class citizen, not an afterthought bolted on.

Three.js: The Quiet Revolution

I chose Three.js for Threelab and I’d make the same choice again in a heartbeat. But the story of why is bigger than one project.

Three.js weekly NPM downloads have roughly doubled from 2.7 million to over 5.4 million in the past year alone — 270 times more than Babylon.js, 337 times more than PlayCanvas.¹ Job listings requiring Three.js and WebGL skills jumped 25% in 2025. When WebGPU shipped across all major browsers in September 2025 — including Safari on iOS, the last major holdout — it unlocked 2–10x performance improvements for complex scenes, and Three.js was ready with zero-configuration WebGPU support from release r171 onward.²

The HTML5 games market hit $3.2 billion in revenue, with JavaScript-based engines powering 89% of browser-based games. Three.js isn’t just a graphics library anymore. It’s the substrate of an entire creative economy.

And then came vibe coding.

The term Andrej Karpathy coined in February 2025 became Collins Dictionary’s Word of the Year by December. The Vibe Coding Game Jam drew over 1,000 submissions. Three.js turned out to be almost perfectly suited for this paradigm: simple setup (just JavaScript, no complex tooling), immediate visual feedback, and a forgiving API that abstracts away GPU complexity while still providing real power. As one analysis put it, Three.js in 2026 is defined by three shifts: “WebGPU becoming production-ready, AI-assisted development lowering the barrier to entry, and the library expanding beyond websites into physical installations.”³

The Open-Source Engine Question

Here’s where things get interesting — and where I think we’re watching a pattern that’s played out before.

At GDC 2026, for the first time in the survey’s history, Unreal Engine pulled ahead of Unity as the most-used primary engine: 42% to 30%, based on responses from over 2,300 game industry professionals. Godot, the open-source engine that W4 Games calls “the fastest-growing piece of game engine technology today,” captured 5% overall and 11% among newer indie developers.⁴

Unity’s story is particularly instructive. It still powers 51% of all games released on Steam in 2024 and dominates mobile with 71% of the top 1,000 mobile titles. But revenue tells a different story: only 26% of Steam revenue goes to Unity-built games, compared to 31% for Unreal and 41% for custom internal engines. Unity has been losing ground since 2021, pressured from above by Unreal Engine 5 capturing AAA and mid-tier studios, and from below by open-source alternatives attracting cost-sensitive indies.

The pricing controversy of 2023 accelerated something that was already in motion. When a platform provider changes the terms on its community, trust fractures — and developers start looking for exits that can’t be rug-pulled. Godot’s MIT license means no runtime fees, no revenue sharing, no forced splash screens, and — crucially — no foundation that can unilaterally change the terms, because the code is open source.

We’ve seen this movie before. Blender‘s trajectory in the 3D modeling space is the closest analogy. A decade ago, Autodesk Maya was the unquestioned industry standard — the tool you had to learn if you wanted to work in VFX, animation, or game art. Autodesk’s subscription model ($1,785/year) and ecosystem lock-in seemed unassailable. But Blender kept improving. Revenue for the Blender Development Fund grew 21% in 2024. What was once dismissed as an amateur’s tool is now used in professional production at studios worldwide. The gap has narrowed from “professional vs. amateur” to “two different philosophies of work.”⁵

Maya hasn’t disappeared — it retains strong positions in feature-film animation and VFX pipelines integrated with Houdini and Nuke. But its dominance is no longer unquestioned, and every year the calculus shifts a little further.

I think the same dynamics will play out with game engines, though the timeline and details will differ. A few distinctions matter here:

Three.js is not a game engine. It’s a general-purpose graphics library — a renderer and scene graph that makes no assumptions about physics, input handling, entity-component systems, or any of the other scaffolding that game engines provide. It’s closer to a creative materials supplier than a construction company. That’s a feature when your goal is composable web graphics; it’s a limitation when you need collision detection and AI pathfinding out of the box.

Godot is a game engine — and it’s the one I’d watch most closely. For platformers, RPGs, roguelikes, and visual novels, it has almost no weaknesses. Its 120MB editor, mature 2D pipeline, and zero license risk make it remarkably compelling for the kinds of games most indie developers actually ship. Its 3D capabilities still lag behind Unity for high-end work, and console porting requires third-party studios ($10K–50K), but these are narrowing gaps, not structural barriers.

Unreal may be the most protected of the incumbents, and for a specific reason: its strengths align tightly with the needs of current AAA development — photorealistic rendering, massive world streaming, Nanite geometry, Lumen lighting. Studios making $100M+ games need those capabilities and are willing to pay for them. Unreal’s moat is technical excellence at the high end, which is the hardest thing for open-source projects to replicate because it requires sustained investment in bleeding-edge R&D.

But the trend line is clear. Open-source tools are capturing the long tail first, then moving upmarket. It happened with Blender. It’s happening with Godot. And at the infrastructure layer, Three.js is quietly becoming the default way the web renders anything in 3D.

The Hard Part: Graphics Through the Eye of a Text Needle

Now for the honest part. Because building Threelab taught me something that tempered my enthusiasm about agentic development — at least in its current form.

Graphics-intensive work is significantly slower to iterate on with AI than text-oriented work. And this isn’t a minor friction — it’s a fundamental modality gap.

When I’m working with Claude Code on backend logic, API design, data transformations — anything primarily expressed in language and structure — the feedback loop is tight. I describe what I want, the agent implements it, I review the output, we iterate. It’s the workflow I described in my piece on self-improving code, and it genuinely feels like having a skilled collaborator.

But when I’m trying to adjust the visual appearance of a generative art pattern — the way particles trail through a flow field, or how bloom interacts with a Voronoi tessellation, or the precise feeling of a camera orbit — something breaks down. I find myself writing paragraphs to describe adjustments that a skilled graphics engineer would make in seconds by tweaking a number and watching the viewport. “Make the particles fade more gradually toward the edges, with a slight blue shift in the trail, and reduce the bloom bleed on the brightest points by about 20%” — this is an awkward, lossy translation of what is fundamentally a visual intention.

[📸 Screenshot: A before/after comparison of a flow field pattern showing the kind of subtle visual adjustment that requires extensive back-and-forth with an LLM]

A talented graphics engineer would have been 10x more productive than me on these specific tasks. Not because the AI lacks capability — Claude Code absolutely understands Three.js and shader mathematics — but because we’re forcing visual communication through a text bottleneck. It’s like directing a painter by writing letters instead of pointing at the canvas.

Recent research confirms this isn’t just a tooling problem — it’s a fundamental limitation. A 2025 survey on spatial reasoning in LLMs (presented at IJCAI 2025) found that “representational grounding — not linguistic fluency — remains the primary bottleneck.” Models struggle to maintain spatial relations when viewpoints shift; they lack anything resembling mental rotation. They can describe what they see, but they can’t think in the visual medium the way a human artist does. Put bluntly: LLMs are still more wordcel than shape rotator. The text channel is lossy in ways that matter enormously for aesthetic and spatial work.

The GDC 2026 sentiment data is striking here. Among visual and technical artists, 64% view generative AI as having a negative impact on the industry — the highest of any discipline. Game designers and narrative professionals aren’t far behind at 63%.⁶ I think this reflects something real beyond just job-security anxiety: the people who work most fluently in visual and spatial languages feel the modality mismatch most acutely. The sentiment shift is dramatic: negative views on AI’s industry impact went from 18% (2024) to 30% (2025) to 52% (2026), while positive views collapsed from 29% to just 7% over the same period.

The Frontier: Visual Languages for Visual Work

This points toward two avenues of development that I think will be transformative — and that aren’t getting enough attention relative to the rush to make text-based agents better at coding.

First: stronger multimodal understanding. Current vision-language models can describe images, answer questions about them, and perform visual reasoning tasks with increasing accuracy. Qwen3-VL-235B now rivals top proprietary models on multimodal benchmarks. But there’s a difference between understanding a visual and manipulating one with the fluency of a practitioner. When I show Claude a screenshot of my scene and say “the energy feels too dispersed”—that’s a visual-spatial-aesthetic judgment that requires translating back into parameter space. We’re getting better at this, but the gap between language-mediated visual reasoning and native visual thinking remains significant.⁷

Second: we need fundamentally different interfaces for visual-spatial collaboration with AI. Not better prompts. Not more screenshots. Something closer to a shared canvas where human and AI can point, sketch, annotate, and reshape in real time.

The earliest compelling prototype of this was tldraw‘s Make Real, which turned an infinite canvas into what Steve Ruiz calls “a conversation space where you and the AI can workshop an idea together.” You sketch, the model generates working code alongside your drawing, you mark up the result, and that markup becomes the next prompt. As Ruiz put it: “we accidentally made a really, really good visual multimodal prompting application.” The hard part, he noted, is getting information into the model, and “pictures are really good” at that.

Since then, the idea has been evolving fast. TalkSketch (November 2025, from researchers at SUTD and Carnegie Mellon) pushes the paradigm further: designers sketch while speaking aloud, and both modalities feed into the AI simultaneously. Their user studies found that text-based interaction “often interrupts creative flow and creates a disconnect between ideation and sketching activities” — designers reported fatigue from “repeatedly typing long prompts to clarify their intent” and overwhelmingly preferred to just draw. TalkSketch’s insight is that speech and sketch together preserve the spontaneity of natural creative dialogue in a way that text prompting simply can’t.

Figma Make (powered by Claude) now turns designs into interactive prototypes, with an MCP server that lets code agents push and pull between canvas and codebase. Spellburst, from Stanford HAI and Replit, gets even closer to Threelab’s domain; it’s an LLM-powered canvas specifically for generative art, where artists prompt, get generated code, then use dynamic sliders to tweak parameters and can click the image to reveal and edit the underlying code directly.

And just this month, Stanford researchers published new findings on AI-artist collaboration. Professor Maneesh Agrawala was blunt: “while the models seem amazing, they are terrible collaborators.” The team’s work on establishing shared “ground rules” between human and AI—including ControlNet for spatial composition that mirrors how artists actually work, from rough blocking to fine detail—points toward a future where the model doesn’t just receive instructions but genuinely participates in a creative conversation.

But here’s what all of these have in common: they work in 2D. Flat layouts, component-based UIs, static images. Nobody has yet built the equivalent for 3D generative art, shader programming, or spatial creative work. When I’m trying to adjust how particles flow through a force field in Threelab, I can’t sketch my intent on a canvas and have the model understand the three-dimensional, time-varying, aesthetic adjustment I’m reaching for.

The visual conversation paradigm exists—but only for flat, component-based interfaces. Extending it into volumetric, dynamic, aesthetic space is the frontier that would change everything for creative 3D work.

Composability as Creative Principle

One of the design choices I’m proudest of in Threelab is the export system. Every scene — no matter how complex its layer stack, its evolved parameters, its bloom and camera settings — can be exported as a single HTML file that runs anywhere a browser runs. No dependencies. No build step. No server. Open it, and it renders.

This is composability made tangible. The exported artifact is a self-contained creative object that can be embedded in a blog post, dropped into a CMS, included in a presentation, or served from a static file host. It participates in the web’s native composition model: hyperlinks, iframes, script tags. It doesn’t need permission from a platform.

I’ve argued before that the open web is the natural substrate for the agentic era — that when AI systems generate software, they overwhelmingly generate web software (HTML, React, Node), making the browser the universal deployment surface. Over 90% of developers now use AI coding assistants regularly, and the output is web-native by default.

Threelab’s export system is a small but concrete instance of this principle. An AI agent can use the MCP tools to create a visualization, evolve it through several generations, and export a standalone HTML file — all without human intervention. That file can then be embedded anywhere on the web. The agent created a composable creative artifact that participates in the open web’s ecosystem.

When I think about where all of this heads — the convergence of agentic AI, open-source graphics tools, and the composable web — I keep returning to that phrase from my market map: the bottleneck isn’t engineering anymore. It’s imagination.

What Comes Next

I started Threelab as something between a creative toy and a technical experiment. What I found is that it’s actually a lens — a way of seeing where agentic creation works brilliantly and where it still breaks down, where open-source tooling is winning and where incumbents retain structural advantages, where the web’s composability model creates genuine leverage and where we need entirely new paradigms of human-AI collaboration.

The 21 patterns in Threelab — from Lorenz attractors spiraling through phase space to slime mold simulations self-organizing on a GPU — are beautiful in the way that mathematics is beautiful. They’re also, in a sense, the easy part. The hard and interesting work is making systems where AI agents and human creators can collaborate on visual, spatial, aesthetic problems with the same fluency they’re starting to achieve on text-based ones.

We’re building the tools for a creative era that doesn’t have a name yet. An era where software doesn’t just compute — it paints, it sculpts, it evolves. Where the browser isn’t just a document viewer but a canvas for generative art that an AI agent and a human being made together, each contributing what the other couldn’t.

The Three.js download counter crossed 5.4 million a week and it’s still climbing. Godot’s community doubles every year. Blender is teaching the industry that open tools win in the long run. And somewhere in the gap between a text prompt and a visual intention, there’s a new kind of interface waiting to be invented — one that speaks in shapes and colors and motion instead of words.

I think the people who build that interface will change everything.

Try Threelab for free: threelab.metavert.io

Threelab is open-source under the MIT license. The project, including full MCP server documentation and API reference, is available on GitHub. If you build something interesting with it, I’d love to see it.

Subscribe now

Further Reading

• Software’s Creator Era Has Arrived: my original piece on natural language as compiler, and why the bottleneck is shifting from implementation to imagination.

• The Agentic Web: Discovery, Commerce, and Creation: when answers become applications and the open web becomes the natural substrate for AI-generated software.

• Market Map of the Agentic Economy: a taxonomy for the era when software builds itself.

• WebGPU Fundamentals: the next generation of browser graphics that’s unlocking the performance gains discussed in this piece.

• npm trends: Three.js vs. Babylon.js vs. PlayCanvas: see the download gap for yourself.

Footnotes

1. npm trends data as of March 2026. Babylon.js downloads approximately 10,000/week; PlayCanvas approximately 8,000/week. The 270x gap is not new — Three.js has dominated the web 3D space for years — but the absolute growth rate has accelerated dramatically since WebGPU support and the vibe coding movement. ↩

2. WebGPU browser support timeline: Chrome/Edge since v113 (May 2023), Firefox since v139 (June 2025), Safari macOS since v26 (September 2025), Safari iOS since iOS 26 (September 2025). Early adopters have reported dramatic performance gains migrating from WebGL to WebGPU — in some cases up to 100x for GPU-compute-heavy workloads. ↩

3. From Utsubo’s “What Changed in Three.js 2026” analysis. The Vibe Coding Game Jam statistic comes from Hugging Face’s VibeGame project. Collins Dictionary’s Word of the Year 2025 selection is its own kind of cultural indicator — when the dictionary notices, a paradigm shift has already happened. ↩

4. GDC 2026 State of the Game Industry Report, based on 2,300+ respondents. The Unreal-over-Unity flip is notable because Unity had led this survey for years. Among AAA studios specifically, Unreal sits at 47%; among AA studios, 59%. ↩

5. The comparison to Blender is imperfect but instructive. Blender’s disruption of Maya (not complete displacement — Maya retains strong positions in VFX and feature animation) followed a pattern: free tool improves relentlessly → professional adoption grows at the margins → cost-conscious studios switch → ecosystem effects compound → incumbents lose pricing power. Autodesk’s Maya subscription at $1,785/year creates ongoing switching incentive every renewal cycle. The Blender Foundation’s 21% revenue growth in 2024 reflects corporate backing from studios that are actively investing in the alternative. ↩

6. GDC 2026 State of the Game Industry Report. The sentiment shift is dramatic: negative views on AI’s industry impact went from 18% (2024) to 30% (2025) to 52% (2026). Positive views collapsed from 29% to 13% to 7% over the same period. Game programmers sit at 59% negative. Only 36% of game studio employees use generative AI tools at all — lower than the 58% in publishing, marketing, and business roles. ↩

7. The multimodal benchmark landscape is evolving quickly. MMMU Pro (academic visual reasoning) and LM Arena Vision (human preference) are the current standard evaluation frameworks. The gap I’m describing isn’t about benchmark performance — it’s about the difference between analytical visual understanding and creative visual manipulation, which is harder to measure and harder to achieve. ↩

But what does this economy actually look like? Where does the value sit, and how does it flow?

Three years ago, at the MIT Media Lab, I argued that the next evolution of digital identity wouldn’t be about who we are online. We would soon project our will onto the internet through intelligent agents. That prediction aged rather well:

I start my day by telling an AI agent what I want my website to say, and it publishes the pages. A different agent discovers and catalogs the emerging ecosystem of other agents. A third agent debugs the tools that the first agent depends on. When I built Chessmata — a complete multiplayer chess platform — over a single weekend using agentic engineering, the gap between what I imagined and what existed collapsed to the time it took me to describe it.

A new stack has emerged — one that describes how intelligence flows from raw silicon through foundation models to the autonomous agents that are beginning to reshape how we build, discover, transact, and create. It needs a map.

I call it The Market Map of the Agentic Economy (click to visit an interactive version of the map).

Layer 1: Agents

At the top of the stack sits the layer people actually interact with: autonomous agents that do things on your behalf.

This is the experience layer of the agentic economy. It’s where Claude Cowork manages my website through conversation, where ChatGPT composes research and builds interactive applications, where Perplexity constructs real-time comparison dashboards instead of returning ten blue links. It’s where OpenClaw—the open-source personal agent that gathered 145,000 GitHub stars in its first week—books flights by digging up corporate rates buried in old email PDFs.

What’s happening: over 100,000 products are built daily on AI-native platforms. Palantir‘s Alex Karp has declared that AI isn’t augmenting enterprise software—it’s replacing it. Agentic AI is projected to reach ~$50–70 billion by 2030 at a 65.5% compound annual growth rate, the fastest-growing enterprise software segment ever.

What separates this layer from everything beneath it is autonomy. These aren’t tools you operate. They’re systems that operate for you, within boundaries you define. The spectrum runs from single-purpose agents like Devin (which writes and deploys code) and Harvey (which handles legal research) to general-purpose agents like Grok, Gemini, Copilot, and Manus that are becoming the default interface to the entire internet.

The economics of this layer are shifting fast. When I wrote about the SaaSpocalypse, I argued that AI agents make individual SaaS products subordinate to agentic workflows. One agent can manage your project without Asana. The per-seat pricing model that built the SaaS industry starts to collapse when a single agent replaces dozens of human software licenses. LLMs are on track to become the integration layer that the software industry spent decades trying to build through APIs and standards bodies—though whether they settle in as “universal middleware” or remain one integration option among several is still playing out.

Agent Discovery

In other software economies, discovery is driven by a combination of advertising, SEO and inbound marketing methods.

In the agentic economy, discovery is collapsing into the experience layer. When you interact with ChatGPT, Claude, or Perplexity, the agent increasingly is the discovery mechanism—there’s no separate step where you browse an app store or click an ad. The intelligence that powers the experience is the same intelligence that mediates what you discover. This shift isn’t total yet; traditional discovery channels still carry enormous traffic. But the trajectory is clear. As I explored in The Agentic Web, 58% of consumers now rely on AI for product recommendations, and 93% of those sessions end without a single click to a website. The interface is the discovery engine. That’s a fundamental restructuring of the internet’s attention economy—and the reason I wrote about enshittification and how agents route around it.

And then there’s what happens when agents talk to each other. Moltbook—the AI-only social network—demonstrated what machine societies look like in practice: over 770,000 autonomous agents posting, commenting, and occasionally launching cryptocurrency tokens. There are now 144 non-human identities per human employee in the average enterprise. We’re already outnumbered in our own systems.

Layer 2: Creation & Orchestration

Beneath the agents sits the tooling that makes them possible: the creator tools, orchestration frameworks, and observability infrastructure that developers and increasingly non-developers use to build, connect, and monitor agentic systems.

This is the layer where software’s Creator Era is most visible. Every creative industry I’ve tracked follows the same three-phase pattern: Pioneer Era, Engineering Era, Creator Era. In the Pioneer Era of AI, you needed a PhD in machine learning. In the Engineering Era, frameworks gave engineers the tools. Now, in the Creator Era, natural language is the programming interface and the population of builders is expanding by orders of magnitude.

Claude Code feels less like autocomplete and more like a staff engineer living in your terminal. I’ve used it to build reinforcement learning training pipelines—setting up PPO networks, configuring reward functions, iterating on architectures. This is the kind of work that two years ago required deep expertise in PyTorch and RL algorithms. Now I describe what I want and agentic tools handle the implementation. Cursor went from zero to $1 billion in annual recurring revenue in 24 months—the fastest B2B SaaS ramp in history. Lovable, Bolt.new, Replit, and v0 are doing to software development what YouTube did to video production: decoupling the creative act from the engineering act.

But creator tools are only one third of this layer. The second third is orchestration and agent runtime—the protocols, frameworks, and execution environments that let agents discover services, communicate with each other, and run reliably.

Anthropic‘s Model Context Protocol (MCP) has become the connective tissue of the agentic ecosystem. Open-sourced in late 2024 and donated to the Linux Foundation in December 2025—co-founded with OpenAI and Block—it now has over 10,000 active servers and 97 million monthly SDK downloads. MCP solved the most immediate problem first: giving agents a standardized way to access tools and data—the equivalent of a USB-C port for AI applications. As even Sam Altman acknowledged when OpenAI announced MCP support: “People love MCP.”

Google‘s A2A (Agent-to-Agent) protocol handles the adjacent problem of inter-agent collaboration. The major platform companies are building their own agent SDKs—OpenAI‘s Agents SDK, Google‘s ADK, and Vertex AI Agent Engine—while frameworks like LangChain, LangGraph, CrewAI, and LlamaIndex provide the independent scaffolding for building multi-agent systems. Cloudflare is emerging as a full-stack agentic infrastructure provider: Cloudflare Agents positions edge compute as the runtime for stateful, long-lived agents; Containers and Sandboxes provide isolated execution environments for untrusted AI-generated code; AI Gateway serves as a unified control point across AI providers with caching, cost tracking, and failover; and VibeSDK is an open-source vibe coding platform that anyone can deploy in one click—complete with code generation, sandboxed preview, and Workers for Platforms for deploying the apps at scale. Zapier and n8n are evolving from workflow automation into agentic orchestration platforms—their thousands of existing integrations becoming tool libraries that agents can compose.

The third piece is observability and evaluation. Companies like Arize AI, LangSmith, and Langfuse are building the monitoring infrastructure that production agent systems require—because a 95% reliable step sounds safe until you chain twenty of them together and your end-to-end success rate plummets to 36%.

What’s happening: Claude Code already accounts for 4% of all GitHub commits and is on track to potentially reach 20%+ by year-end. 41% of all code written globally is now AI-generated. The vibe coding platform market hit $4.7 billion and is projected to reach $12.3 billion by 2027.

Layer 3: Platforms & Services

Every Creator Era generates a surge of new builders: and those builders need infrastructure that makes scaling effortless. That’s what Layer 3 provides: the databases, deployment platforms, frameworks, and services that handle genuinely difficult problems so that creators can focus on building.

This is the layer I’ve been most personally invested in. When I wrote about the companies that win in Creator Eras, I identified toolmakers for hard problems as a key category. Not every problem dissolves in the face of agentic AI. Scaling a real-time application to millions of users is still hard. Managing globally distributed databases is still hard. Deploying and orchestrating containers at scale is still hard. My own company, Beamable, is built around this conviction: that the Creator Era needs infrastructure for hard problems, not just easier ways to generate code.

Companies like MongoDB, Fly.io, Vercel, and Cloudflare (whose Workers and Containers have become go-to infrastructure for deploying agentic apps at the edge) are building platforms that handle these infrastructure challenges—the kind that don’t go away just because a non-engineer is now building the application. The hyperscalers play here too: Azure, GCP, and AWS aren’t just compute providers at Layer 6—their platform-as-a-service offerings, managed databases, and deployment tooling make them some of the largest Layer 3 players by volume. When an agent deploys a container, provisions a database, or wires up an API gateway, it’s often routing through the same cloud platforms that also sell the raw compute underneath. If anything, as millions of new creators start building software, the demand for platforms that make scaling effortless goes up, not down. Neon—a serverless Postgres platform—already reports that 80% of its databases are created by AI agents, not humans. That’s a leading indicator of where this layer is heading.

Stripe‘s positioning is particularly interesting. Their Agentic Commerce Protocol (ACP), co-developed with OpenAI, is building the payment rails for agent-mediated transactions. Google‘s Universal Commerce Protocol (UCP)—open-sourced in January 2026—takes a complementary approach, providing a standard for how agents discover, evaluate, and transact with merchants. McKinsey estimates that AI agents could mediate $3 to $5 trillion in global consumer commerce by 2030. When an agent completes a purchase on your behalf, these protocols determine how the transaction flows—bridging traditional commerce infrastructure and the emerging agent economy.

Shopify represents another dimension: commerce infrastructure that agents can navigate. As I explored in The Agentic Web, when discovery, evaluation, and purchase collapse into a single agentic flow, the platforms that expose their catalogs to agents will capture disproportionate value.

Vector databases like Pinecone and Weaviate represent an entirely new subcategory—infrastructure that didn’t exist five years ago but is now essential for retrieval-augmented generation, the pattern that grounds agents in real data rather than hallucination. Databricks and Snowflake provide the data platforms where enterprises organize the information that agents need—and Snowflake’s Cortex Agents are blurring the line between data platform and agent runtime.

On the enterprise side, ServiceNow AI Agents represent the incumbent bet: that the companies already embedded in enterprise workflows have a natural advantage when those workflows become agentic. Salesforce‘s Agentforce makes the same play from the CRM angle.

What’s happening: Supabase has become the default backend for vibe-coded applications. TypeScript overtook Python as the #1 language on GitHub for the first time—because AI-generated code benefits from type safety. The platforms that thrive will be the ones whose value increases with every new creator who builds on them. Composability creates network effects, and network effects create moats.

Layer 4: Foundation Models & Intelligence

This is the layer that made everything above it possible. Foundation models are the engines of the agentic economy: the systems that understand language, generate media, reason about code, and increasingly, take sustained autonomous action.

The landscape divides into three distinct territories.

Language and reasoning models are the backbone. Claude, GPT / o-series, Gemini, Grok, Llama, Mistral, DeepSeek, and Qwen—the competition here is fierce and the pace of improvement is staggering. Claude Opus 4.5 hit 80.9% on SWE-Bench Verified, up from 33% eighteen months ago. On GPQA Diamond—PhD-level scientific reasoning—Claude Opus 4.6 scored 91.3%, exceeding human experts by over 21 points. METR’s benchmark shows autonomous task horizons crossing a full work-day at 14.5 hours, doubling every 123 days. At that rate, week-long autonomous tasks arrive by late 2026.

But perhaps the most consequential shift is economic: AI inference costs dropped 92% in three years, from $30 per million tokens to $0.10–$2.50. When I wrote about the Direct from Imagination era, I described a future where people would speak entire worlds into existence. The enabling condition wasn’t just model intelligence—it was model economics. At $30 per million tokens, agentic workflows are a luxury. At $0.10, they’re table stakes.

Generative media models represent the creative frontier. Midjourney, Runway, Black Forest Labs (creators of Flux), Sora, Veo, ElevenLabs, Suno AI, and Stability AI are collectively doing to media production what LLMs are doing to code. Kling (from Kuaishou) represents the Chinese frontier in video generation.

World models and embodied AI represent the emerging third territory, where models learn to understand and interact with the physical world. AMI Labs—Yann LeCun’s new venture, which raised a record-setting $1.03 billion seed round—is building world models using JEPA (Joint Embedding Predictive Architecture), a fundamentally different approach to learning abstract representations of physical reality. World Labs, founded by Fei-Fei Li, is pushing into 3D world generation. Figure AI and Physical Intelligence are connecting models to physical actuators. This is where the agentic economy eventually meets atoms—and where Tesla‘s investment in Full Self-Driving and Optimus is a bet not just on transportation but on the physical manifestation of agent intelligence.

The open-source vs. proprietary tension at this layer is real and productive. Meta‘s Llama, DeepSeek, and Mistral are democratizing access—mirroring the decentralization tension I identified in the metaverse value-chain. The question of who controls the intelligence is the most consequential structural question of the agentic economy.

What’s happening: Cohere is pursuing the enterprise-focused path, optimizing for retrieval and search rather than general reasoning. The frontier labs push capability boundaries that open-source trails by months, not years. The result is a competitive dynamic that benefits everyone building on top.

Layer 5: Knowledge & Substrate

Models are only as good as what they learn from. Layer 5 is the knowledge substrate of the agentic economy: the data assets that models train on, the model-building toolchain that enables that training, and the platforms where human knowledge accumulates.

This layer has a unique property: it’s simultaneously the most valuable and the most contested. The companies that control proprietary data at scale have an asset that becomes more valuable as models become more capable.

X is perhaps the most strategically interesting asset here—not as a social network, but as a real-time data firehose. When xAI acquired Twitter, they didn’t just buy a social platform. They bought the internet’s most comprehensive real-time knowledge graph: every news event, every public conversation, every expert opinion, timestamped and linked. That data is now feeding Grok’s training pipeline directly, giving xAI a data advantage that no amount of web crawling can replicate.

YouTube (Google) and GitHub (Microsoft) represent similar strategic assets. YouTube’s transcripts are disproportionately powerful for model training—research shows that 7-billion-parameter models trained on high-quality YouTube transcripts outperform 72-billion-parameter models with lower-quality data. GitHub is the world’s largest repository of code, and Microsoft’s ownership of it provides an unmatched advantage in code generation.

The model-building toolchain at this layer—PyTorch (Meta), JAX (Google), CUDA (NVIDIA)—are the compilers of the AI era. They translate mathematical intent into the parallel computations that produce intelligence. PyTorch has become the de facto standard for research; CUDA remains the gravitational center of GPU computing. These frameworks sit at the intersection of data and compute—the tooling that transforms raw knowledge into trained models.

What’s happening: Data licensing has become a multi-billion-dollar market. Reddit went public partly on the strength of its data licensing deals with AI companies. The question of who owns training data—and who profits from it—is reshaping copyright law, journalism, and the economics of content creation.

Layer 6: Inference & Compute

Training a model requires enormous compute. Running it—inference—requires a different kind of enormous compute: lower latency, higher throughput, and increasingly, the ability to sustain long-running agentic sessions that last hours or days.

The inference economy is emerging as a sector distinct from training. a16z’s analysis points in this direction: custom ASICs already handle 40% of inference workloads, and companies like Together AI grew from $30 million to $300 million ARR in a single year. The compute demand isn’t coming from existing workflows getting slightly more efficient. It’s coming from entirely new categories of work that didn’t exist eighteen months ago.

This layer splits into two territories. AI-native compute providers like CoreWeave, Groq (with its LPU architecture optimized for inference speed), Lambda Labs, and Fireworks AI are purpose-built for the workloads the agentic economy generates. xAI‘s Colossus cluster—one of the world’s largest AI supercomputers—and OpenAI‘s Stargate project ($500 billion committed, the largest infrastructure investment since the Interstate Highway System) represent the frontier of what’s being built.

Hyperscale cloud providers—AWS (Amazon), Azure (Microsoft), GCP (Google), and OCI (Oracle)—are the established infrastructure that most enterprises route their AI workloads through. They’re responding to AI-native competitors by building out GPU clusters, offering inference-optimized instances, and integrating foundation models directly into their platforms.

The emerging risk is what you might call inference famine: demand for inference compute is growing faster than supply can scale, even at these unprecedented investment levels. As agents become capable of sustained multi-hour autonomous sessions and agentic workflows chain dozens of model calls per task, the compute footprint per user is exploding. The bottleneck is shifting from training—which is expensive but episodic—to inference, which is continuous and compounding.

What’s happening: Big Tech alone is committing over $700 billion in AI capex in 2026: Amazon at $200 billion, Google at $180 billion, Meta at $115–135 billion, Microsoft at $80 billion. That’s not software spending—it’s industrial-scale infrastructure investment, more comparable to building railroads or power grids than to launching software products.

Layer 7: Physical Infrastructure

Everything above depends on atoms. Silicon chips, networking equipment, data centers, cooling systems, and the energy to power all of it.

When I wrote the Metaverse Value-Chain, infrastructure was the foundation of the whole stack. That has never been more literally true—and the stakes have never been higher. Global data center power consumption is projected to hit 96 gigawatts in 2026: the equivalent of nine New York Cities. The grid investment required—$720 billion—rivals the AI capex itself.

NVIDIA occupies a singular position at the center of this layer—and, increasingly, well beyond it. Jensen Huang’s team has demonstrated what some call “Huang’s Law”: since 2012, actual AI compute has improved 300,000x, compared to the 7x that Moore’s Law would have predicted. The Rubin chip (Q2 2026) promises 5x inference performance over Blackwell. But NVIDIA’s ambitions now extend far up the stack: NeMo and NIM provide agent development and inference microservices (Layer 2–3), Nemotron delivers open foundation models optimized for agentic AI (Layer 4), CUDA remains the gravitational center of GPU computing (Layer 5), and DGX Cloud offers managed compute (Layer 6). NVIDIA is becoming a full-stack AI platform company, not just a chipmaker. But it isn’t alone at Layer 7: AMD, Cerebras (wafer-scale computing), Tenstorrent (Jim Keller’s RISC-V AI chips), and SambaNova are all pursuing alternative architectures. The hyperscalers are building their own silicon too: Google‘s TPUs, Meta‘s MTIA, Microsoft‘s Maia 200 (a custom inference ASIC built on TSMC’s 3nm process), Apple Silicon, and Tesla‘s D1/Dojo chips.

Behind the chip designers sit the manufacturers and equipment makers that make fabrication possible. TSMC fabricates the vast majority of the world’s most advanced chips—making it arguably the single most critical company in the entire agentic economy. ASML’s EUV lithography machines, which cost over $350 million each, are the only equipment on Earth capable of printing at the cutting-edge nodes AI chips require. This is one of the most concentrated dependencies in the global technology stack: a single Dutch company’s machines are the bottleneck for the entire AI hardware supply chain.

And underneath everything: energy. Constellation Energy restarted Three Mile Island specifically to power a Microsoft data center. Oklo, backed by Sam Altman, is developing small modular nuclear reactors designed for data center power. The constraint on AI isn’t software anymore. It’s atoms.

Comparing the Titans of the Agentic Economy

A layered framework is only useful if it reveals something you can’t see without it. The real test: take companies that look similar from the outside and show how they occupy the layers in fundamentally different ways.

Anthropic occupies three layers with remarkable focus. Claude at Layer 1 (as one of the two leading frontier agents), Claude Code and MCP at Layer 2, and the Claude model family at Layer 4. Anthropic’s strategy is depth over breadth. It doesn’t own data, compute, or silicon—it relies on partners (primarily Amazon and Google for cloud). This is a deliberate bet that model quality and developer ecosystem can win without vertical integration. With MCP winning the protocol adoption race and 4% of GitHub commits authored by Claude Code, the bet is paying off.

OpenAI is the most aggressive at vertical expansion. ChatGPT at Layer 1. Codex at Layer 2. The Agentic Commerce Protocol (ACP), co-developed with Stripe, at Layer 3—building the payment and transaction rails that agents use to buy things on your behalf. GPT and o-series models plus Sora at Layer 4. The Stargate project at Layer 6 represents a $500 billion bet on owning compute infrastructure. OpenAI is trying to be vertically integrated from models to infrastructure—a strategy that requires enormous capital but creates enormous leverage if it works.

Google rivals only Amazon for the most comprehensive layer coverage in the agentic economy. Gemini at Layers 1 and 4. A2A and ADK at Layer 2. The Universal Commerce Protocol (UCP), Firebase, and Google Workspace APIs at Layer 3—Gmail, Calendar, and Drive are already default integration targets for agentic code, and UCP is positioning Google at the center of agentic commerce. YouTube at Layer 5—the single most valuable training data asset on the internet. GCP at Layer 6. TPUs at Layer 7. Google’s advantage is breadth: they have meaningful presence at every single layer. Their challenge is that being everywhere means competing with specialists at every layer simultaneously. But in a world where data is the ultimate moat, owning YouTube may matter more than any other single asset.

Meta and xAI make an instructive pair, because both own massive social platforms that feed proprietary data into their models — but they’re deploying that advantage in opposite ways.

Meta’s data advantage comes from Facebook, Instagram, and WhatsApp: billions of users generating text, images, video, and social graph data across multiple modalities. That data trains Llama, which Meta then open-sources. This is the most distinctive strategic move in the agentic economy: Meta is the only frontier lab releasing fully open-weight models. Llama at Layer 4 is the most widely-deployed open-source model family, and PyTorch at Layer 5 is the de facto standard for ML research. Meta is also making one of the largest infrastructure bets in the industry: with $115–135 billion in projected 2026 capex and 21+ owned data centers, Meta’s Layer 6 presence is substantial—even if it’s less branded than Stargate or Colossus. MTIA at Layer 7 reduces their dependence on NVIDIA. The bet is that commoditizing the model layer through open source concentrates value in the places where Meta has unique advantages: its social graph, its data, and its ability to deploy AI across platforms with billions of users. It’s the same strategic logic that led them to open-source React — commoditize the complement, and draw an entire ecosystem toward your orbit.

xAI’s data comes from X: a different kind of asset. Where Meta’s data is social and multimodal, X is the internet’s densest real-time knowledge graph: every news event, every public conversation, every expert opinion, timestamped and linked. That data feeds Grok’s training pipeline directly, optimizing for timeliness and public discourse rather than the social and visual signals Meta captures. Grok at Layers 1 and 4. Colossus, one of the world’s largest GPU clusters, is a substantial Layer 6 investment. Through Tesla, there’s a connection to Layer 7 (Dojo chips) and to embodied AI (Full Self-Driving, Optimus). Where Meta open-sources to commoditize, xAI vertically integrates to control: data, compute, and models in a closed flywheel, with a distribution platform on top. It’s the most vertically ambitious play in the space.

Microsoft plays the game differently: it’s the picks-and-shovels provider wrapped in enterprise distribution. Copilot at Layer 1. GitHub Copilot and Agent Framework at Layer 2. Azure’s platform services and Dynamics 365 at Layer 3—Azure isn’t just compute; its PaaS offerings, managed databases, and app services make it one of the largest agentic deployment platforms. GitHub and LinkedIn at Layer 5—the world’s largest code repository and the world’s largest professional knowledge graph, respectively. Azure at Layer 6. Maia 200—Microsoft’s custom inference ASIC, built on TSMC’s 3nm process—at Layer 7. Microsoft’s $13 billion investment in OpenAI gives it access to frontier models without building them. The question isn’t whether enterprises will adopt AI agents—it’s whether they’ll adopt them through the Microsoft stack they’re already paying for. Every Fortune 500 company already runs on Microsoft. That distribution advantage is hard to overstate.

Amazon is the quiet giant of the agentic economy—present at every single layer, but often as the infrastructure behind someone else’s headline. Alexa at Layer 1, now upgraded with generative AI capabilities, is the world’s most widely-deployed voice agent—present in hundreds of millions of devices. Nova Act, a browser automation agent launched on AWS, extends Amazon into task-oriented agent territory. Bedrock AgentCore and the Strand SDK at Layer 2 provide managed services for building, deploying, and operating agents at enterprise scale. AWS at Layer 3 is the world’s largest cloud platform—Lambda, S3, DynamoDB, and API Gateway are the default infrastructure that agentic applications deploy to, with a $244 billion revenue backlog as of early 2026. The Amazon Nova model family at Layer 4 gives Amazon its own frontier models, reducing dependence on partners (though its $4+ billion investment in Anthropic hedges that bet). Amazon’s retail data at Layer 5—the world’s largest product catalog, consumer purchase behavior, and logistics data—is an asset whose value for agentic commerce is hard to overstate. AWS at Layer 6 represents the single largest infrastructure commitment in the industry: $200 billion in 2026 capex, with Project Rainier operating the world’s largest AI training cluster built on custom silicon. And at Layer 7, Trainium (training), Inferentia (inference), and Graviton5 (general compute) chips give Amazon a silicon strategy rivaling any hyperscaler. Amazon’s strategic position is unique: it’s simultaneously the infrastructure partner for multiple frontier labs—including Anthropic—and an increasingly direct competitor to them.

Apple looked like the conspicuous underperformer in early versions of this framework—but a closer look reveals a more deliberate strategy. Apple Intelligence at Layer 1 is behind the frontier in raw model capability, but Apple is playing a different game. Xcode 26 brought AI-assisted coding to Apple’s developer platform at Layer 2, integrating third-party models like Claude and ChatGPT directly into the IDE—with agentic coding capabilities arriving in Xcode 26.3. At Layer 3, the App Intents framework is Apple’s quiet power play: by letting any app expose its capabilities to Apple Intelligence and Siri, Apple is turning its entire ecosystem into a structured service layer that agents can navigate. Apple Pay adds transactional infrastructure. Apple Private Cloud Compute at Layer 6—running on custom Apple Silicon servers with a privacy-first architecture—provides the inference backbone, backed by a $500–600 billion commitment to US infrastructure. And Apple Silicon at Layer 7 remains the world’s most advanced edge AI chip. Apple controls the device that two billion people carry in their pockets. As I wrote in Enshittification and the Future of AI Agents, to ensure that agents have our interests in mind, we’ll want to preserve our freedom to select and parameterize them however we choose. Device-based LLMs are central to that vision, and Apple controls more of the device layer than anyone.

NVIDIA spans six layers—and it’s not the company most people expect to see across that much of the stack. GPUs at Layer 7 are where NVIDIA’s dominance is obvious: Blackwell and the upcoming Rubin architecture are the physical substrate of AI. But NVIDIA has been quietly building upward through the entire stack. DGX Cloud at Layer 6 offers managed compute for training and inference. CUDA at Layer 5 remains the gravitational center of GPU computing—the substrate that every other layer depends on. Nemotron, NVIDIA’s family of open models optimized for agentic AI, occupies Layer 4. NIM microservices provide inference deployment infrastructure at Layer 3. And NeMo—NVIDIA’s agent development toolkit, along with the NeMo Claw open-source agent platform announced at GTC 2026—positions them at Layer 2. NVIDIA is becoming a full-stack AI platform company. The strategic logic is clear: if you make the silicon that everything runs on, you have a natural advantage in optimizing every layer above it. Whether the market accepts NVIDIA as a software platform company—not just a chipmaker—is one of the most consequential bets in the space.

The pattern that emerges is instructive. These companies aren’t building the same thing at all. They’re placing bets on which layers of the stack will capture the most value, and the specifics of those bets reflect deeply different visions of how the agentic economy will evolve.

The Composability Thesis

If there’s a single principle that governs how value flows through these seven layers, it’s composability.

I’ve written about how composability is the most powerful creative force in the universe: how in biology, culture, software, and finance, the ability to aggregate, transmit, and iterate components produces emergent creativity that no single actor could achieve alone. The agentic economy is the most composable system humanity has ever built.

Consider the stack in action. A user describes what they want in natural language (Layer 1). An agent orchestrated through MCP discovers the right tools and services (Layer 2). Those services—databases, payment processors, deployment platforms—handle the hard infrastructure problems (Layer 3). The agent’s intelligence comes from foundation models (Layer 4) trained on the accumulated knowledge of the internet (Layer 5), running on specialized compute (Layer 6) powered by cutting-edge silicon and energy (Layer 7).

Every layer is modular. Every layer is replaceable. You can swap Claude for Gemini at Layer 4. You can swap AWS for CoreWeave at Layer 6. You can swap MongoDB for Neon at Layer 3. The interfaces between layers—MCP, A2A, REST APIs—enable recombination without requiring any single company to own the whole stack. This is precisely the architecture that produces maximum emergent creativity: interoperable primitives rather than monolithic solutions.

The network effects compound. There are now over 17,000 MCP servers. That follows Reed’s Law, where network value grows as 2^n with subgroup formation, not just Metcalfe’s n². Every new tool connected to the network makes every agent more capable. Every new agent on the network makes every tool more valuable. The degree to which a network facilitates interconnections determines the extent of its emergent creativity, innovation, and wealth. Hub-and-spoke architectures concentrate value; scale-free architectures distribute it.

This is why I think the open web has a structural advantage—though it’s an advantage, not a certainty. As I argued in The Agentic Web, agents prefer open protocols because they enable composition. The web is the only substrate flexible enough to serve as both the canvas and the runtime for dynamic creation. The agentic web doesn’t just serve information—it synthesizes, composes, and acts.

Walled gardens will persist at certain layers—Apple’s device ecosystem, Meta’s social graph, xAI’s data firehose—and their staying power shouldn’t be underestimated. But if history is any guide, the overall trajectory favors composability over control. The most powerful systems tend to emerge from interoperable primitives, not monolithic solutions. That’s the lesson from biology, from the internet’s own architecture, and from every creative industry I’ve studied for the past decade. The question isn’t whether open systems win everywhere; it’s which layers remain open and which close up around whoever builds the strongest gravity well.

What Comes Next

The disruption is happening to software itself: the substrate beneath everything in technology. And it’s happening through agents that are learning to collaborate, to compose, to improve their own tools, and to form emergent societies that we’re only beginning to understand.

The seven layers I’ve mapped here aren’t static. They’ll shift, subdivide, and recombine. New layers may emerge. Some companies will leap across layers in ways we can’t yet predict. The comparison of frontier companies I’ve drawn will look different in twelve months.

But the underlying dynamics will persist. Value flows upward from atoms to intelligence to agency. The companies that control scarce resources at the lower layers—TSMC’s fabrication, NVIDIA’s architecture, the hyperscalers’ data center footprints—have structural advantages that are hard to replicate. The companies that build the most composable, developer-friendly platforms in the middle layers will capture the network effects of the Creator Era. And the companies that best understand how to project human will through agents—the ones that collapse the gap between intention and implementation—will define the experience layer.

38% of startups are now solo-founded, up from 22%. Smaller teams accomplish what previously required hundreds. The Creator Era is producing an explosion of new participants, new forms, and new economic opportunity—exactly the pattern that plays out in every creative industry when the barriers to creation drop below the threshold of mainstream access.

When I spoke at MIT about projecting our will through intelligent agents, I was describing a future that seemed far away… But the time has already arrived. The seven layers of the agentic economy are the map of how it works.

The bottleneck isn’t engineering anymore. It’s imagination.

The full interactive infographic of The Seven Layers of the Agentic Economy is available on metavert.io.

Subscribe now

Further Reading

My earlier work on frameworks and market maps:

• Software’s Creator Era Has Arrived — Pioneer, Engineering, Creator and the SaaSpocalypse

• The State of AI Agents in 2026 — 200+ slides of research on where agents stand today

• The Agentic Web: Discovery, Commerce, and Creation — When answers become applications

• The Direct from Imagination Era Has Begun — Speaking worlds into existence

• Software, Heal Thyself: Self-Improving Code — The strange loop where agents debug the tools they depend on

A few years ago, this would seem like magic.

This wasn’t a research experiment. It was just Monday.

I’ve been running my website, metavert.io, on LightCMS: the open-source content management system I built with Claude Code for the age of AI agents. The entire site is managed through conversation: I tell an AI agent what I want, and it creates pages, updates themes, publishes content. No dashboard, no forms, no page builder loading screens. This is the workflow I described in I Built a CMS for the Age of Agents: the website as conversation.

But something happened during a routine content update session that caught my attention. Something that shows us the future of software development.

The Wheels Within Wheels

Here’s what my typical website update looks like in 2026. I open Anthropic’s Cowork: a desktop AI agent that connects to LightCMS through MCP (the Model Context Protocol) — and I type something like: “Update the /lightcms page to reflect the latest version changes, and update the version history to match the changelog on GitHub.”

The agent takes it from there. It fetches the current page content, reads the changelog from GitHub, identifies what’s changed, crafts the updated HTML, publishes the pages, and then opens a browser tab to visually verify the rendering. The version history page went from documenting five releases to nine. The marketing page updated its tool count from 43 to 54 and added descriptions of every new feature. All through a single conversational prompt.

This is remarkable enough on its own. But the really interesting thing isn’t the update itself. It’s what happened before it.

“Based on Your Experience, What Would You Change?”

Over the course of several work sessions, I’d been watching Claude Cowork manage my website. It was capable, but I noticed friction. The agent sometimes needed three API calls where one should have sufficed. It would publish a page and then immediately open a browser to verify the rendering, because there was no way to preview content before making it live. Occasionally, a content update would silently reset the site’s theme to blank defaults, requiring the agent to perform a manual revert-and-regenerate dance after every single edit.

So I did something that felt natural but was, in retrospect, kind of extraordinary: I asked the operator agent for its improvement suggestions.

“You’ve been doing a lot of work with LightCMS. Based on your experience, is there anything you’d like me to change about the MCP and/or agentic interfaces to make it easier for you to efficiently control and improve my website?”

The response was immediate, specific, and prioritized by pain. Eight improvement requests, ordered by how much friction each one caused in practice:

The theme-clearing bug was flagged as critical: the agent estimated it accounted for 30–40% of redundant tool calls in a typical session. Batch publish was high priority because the agent was making five sequential publish calls after every theme restore. Content preview was requested because the only way to verify rendering was to publish first and then visually inspect in a browser. Theme version pinning was suggested as an architectural safeguard. Scoped search-and-replace was requested because site-wide replacement felt risky when the agent only needed to change content in one folder.

I then formatted these suggestions as a prompt and handed them to a completely different AI agent: Claude Code, which has access to the LightCMS source code.

Two Agents, Two Epistemologies

Here’s where the story gets interesting for anyone thinking about multi-agent systems.

I’d also previously asked Claude Code — the agent that built LightCMS — for its own suggestions on improving the agentic interfaces. It had a different perspective. Where Cowork’s suggestions were grounded in operational experience (”I had to do this three-step workaround every time I updated a page”), Claude Code’s suggestions were grounded in architectural analysis (”a batch endpoint would reduce round trips”).

Some ideas converged: both agents wanted batch operations, both wanted content preview, both wanted better tool descriptions. But there were critical divergences. The theme-clearing bug — which Cowork flagged as the single highest-priority issue, the one that was tripling its API calls and risking visual breakage on the live site — didn’t appear in Claude Code’s analysis at all. Claude Code had never operated the software in production. It had only built it. The bug was invisible from the inside.

This is, I think, a genuinely new epistemological pattern in software development. The operator agent has experiential knowledge (it knows what’s painful because it feels the pain). The code agent has architectural knowledge (it understands the system’s structure and can reason about what’s possible). Neither perspective alone is sufficient. The bug that mattered most was only visible to the agent doing the work.

The parallels to human organizations are immediate and obvious. How many critical bugs persist in production software because the developers who built it have never used it the way real users do? How many “minor inconveniences” turn out to be the friction that drives 40% of support tickets? The gap between building software and operating software has always existed. What’s new is that AI agents can bridge it—if you let them talk to each other.

The Fix

Claude Code took the improvement requests and went to work. In a single session, it implemented all eight changes and then some — 13 new MCP tools, taking the total from 41 to 54. Batch publish. Content preview with validation warnings. Scoped search-and-replace. Upload assets from URL. Theme version pinning. Update content by URL path instead of database ID. And the critical theme-clearing fix.

After deploying the new version, I reconnected Cowork and asked it to verify the changes. The agent ran a comprehensive non-destructive test suite: created a temporary test page, performed content updates, checked for theme side effects, tested the new preview endpoint, verified the search-replace response format, and cleaned up after itself. It confirmed the theme-clearing bug was fixed, all new tools were functional, and the workflow that previously required three API calls now required one.

Then came the real test: the version update session I described at the beginning of this article. Cowork used publish_multiple(the new batch publish tool) to publish both updated pages in a single call. It used get_content with the new include_rendered parameter to verify page content without opening a browser. The entire session was noticeably faster and cleaner than previous ones. The software had improved itself, and the improvement was immediately measurable in the operator agent’s efficiency.

The Autopoietic Loop

What I’ve described isn’t just a workflow. It’s a loop. And it’s a loop that gets tighter with every iteration.

Douglas Hofstadter called them strange loops1 — self-referential systems where moving through the levels of a hierarchy eventually brings you back to where you started, but transformed. Kenneth Reitz, writing about the recursive architecture of software and consciousness, put it in terms that resonate with what I watched happen to LightCMS:

That’s exactly what’s happening here. The software’s operator generates the feedback that shapes the code that changes the software that the operator uses. You can’t point to where the loop begins.

The biological concept I keep returning to is autopoiesis: the property of systems that produce and maintain themselves. The term was coined by biologists Humberto Maturana and Francisco Varela in the 1970s to describe living cells: systems whose components participate in the very processes that produce those components. A cell manufactures the enzymes that synthesize the membranes that contain the enzymes. The system sustains itself through circular causation.

Software has never been autopoietic. It’s always required external agency (human developers) to maintain and improve it. But what I’m seeing with this multi-agent loop is something that rhymes with autopoiesis. The operator agent uses the software, discovers its limitations, produces improvement specifications, and those specifications get implemented by the code agent, producing a better version of the software that the operator agent then uses more effectively. The software isn’t fully self-producing. But the gap between “requires human intervention” and “generates its own improvement trajectory” has narrowed dramatically.

The human has become more of an orchestrator than a mechanic.

A recent article from Arize AI, “Closing the Loop: Coding Agents, Telemetry, and the Path to Self-Improving Software”(February 2026), describes a closely related pattern: systems that use telemetry and feedback loops to automatically improve their own prompts, error-handling, and code quality without constant human intervention. They call these “self-healing architectures” — systems with persistent memory that learn from operational errors and optimize themselves over time. What I’m describing goes a step further: not just a single agent healing itself, but two specialized agents cooperating to create improvements that neither could achieve alone.

The academic literature is catching up to this reality. A February 2026 paper, “Agyn: A Multi-Agent System for Team-Based Autonomous Code Generation”, describes structured multi-agent frameworks where different agents take distinct roles: researcher, coder, reviewer, tester. Each have role-specific model configurations. And a large-scale study by Liu et al. (2026) examines how frameworks like LangChain, CrewAI, and AutoGen are reshaping software development through multi-agent coordination. The ecosystem is growing fast: METR’s benchmark from February 2026 shows that AI agents can now sustain autonomous work for 14.5 hours, with that horizon doubling every 123 days.

But most of this research focuses on agents collaborating within a single task: multiple agents working together to write code, or to research and synthesize information. What I haven’t seen much of is the pattern I’ve been living with: agents collaborating across time and across roles, where one agent’s operational experience becomes the improvement specification for a different agent working on the underlying system. The operator-to-builder feedback loop.

The Convergence Pattern

This experience has made me think about a pattern I’m calling convergent multi-agent improvement. Here’s the structure:

1. An operator agent runs the software in production, accumulating experiential knowledge about friction, bugs, and inefficiencies. This knowledge is grounded, specific, and weighted by actual impact.

2. A code agent has architectural knowledge of the system. It can reason about what’s feasible, what’s elegant, and what’s risky. But it lacks operational context.

3. A human director orchestrates the loop, translating between the agents, making judgment calls about priorities, and deciding when to ship. The human provides the vision; the agents provide the implementation and the feedback.

4. The software itself is the shared artifact that both agents interact with — one from the outside (operating it), one from the inside (building it). Each iteration makes the software more fluent for agentic operation, which in turn makes the next iteration faster.

What makes this powerful is the complementarity of the two perspectives. In my experience, the operator agent found the critical bug (theme clearing) that the code agent was blind to. The code agent suggested architectural improvements (webhooks, event streams) that the operator agent hadn’t considered because it was focused on immediate pain. Together, they produced a better improvement plan than either would have generated alone.

This rhymes with something I wrote about in The Age of Machine Societies: when agents interact, the system-level behavior can differ significantly from what any individual agent was designed to do. The emergent property here is software that identifies and specifies its own improvements. No individual agent was designed to do that. But the loop between them produces it.

Why This Matters Beyond My Website

I’ve told this story through the lens of my own CMS because that’s where I lived it. But the pattern is general, and I think it’s going to become one of the defining dynamics of the creator era of software.

Consider what happens when this pattern scales:

Enterprise software could deploy operator agents that continuously use their own products the way customers do, generating improvement specifications grounded in real usage patterns rather than support ticket abstractions. The feedback loop from user experience to code change could tighten from weeks to hours.

Open-source projects could have contributor agents that both use and improve the codebase — submitting pull requests based on friction they encounter while performing real tasks. Imagine an agent that uses a library to build something, discovers an ergonomic problem in the API, and opens a PR to fix it — all autonomously.

Infrastructure platforms could use operator agents as continuous integration testers that don’t just verify correctness but evaluate usability — flagging APIs that require too many steps, documentation that’s ambiguous, or error messages that don’t help the caller recover.

The common thread is that software gets a nervous system. Not just logging and monitoring (which tells you what happened), but experiential feedback from agents that actually use the software as a tool (which tells you what shouldchange). The difference is the gap between a thermometer and a person who feels cold.

The reason this pattern can scale is composability. I’ve written before about how composability is the most powerful creative force in the universe: from biological systems to software to culture, composability creates power wherever there are means of aggregating, transmitting, and iterating components. That’s precisely the structure of this multi-agent loop: the operator agent aggregates experiential knowledge, MCP transmits it as structured feedback, and the code agent iterates on the codebase. Each element is modular and recombinable. Swap the operator agent for one that tests accessibility instead of content management. Swap the software for an API gateway or a design system.

The loop itself is composable; that’s why it generalizes.

When I wrote in Software’s Creator Era Has Arrived that “the gap between intention and implementation has collapsed,” I was thinking about human creators using AI to build software faster. But there’s a corollary: the gap between using software and improving software is also collapsing. And it’s collapsing because agents can occupy both sides of that gap simultaneously.

The Trust Curve

In my workflow, I’m still the orchestrator. I’m the one who decided to ask Cowork for suggestions. I’m the one who formatted the suggestions and handed them to Claude Code. I’m the one who decided to deploy the new version and asked Cowork to verify it. The loop required human judgment at every transition point.

But the transitions are getting smaller. In the history of abstraction: from machine code to assembly to high-level languages to AI-generated code. Each step starts with humans closely supervising the new layer, then gradually letting go as trust builds. Grace Hopper’s team created the first compiler in 1952; skeptics insisted real programmers would always need to write machine code directly. By the 1970s, almost nobody was writing assembly for business applications.

I suspect the same trust curve applies here. Today, I’m reviewing the improvement specifications before handing them to the code agent. Tomorrow, that handoff might be automatic, with the human reviewing only the final output. Eventually (not tomorrow, but not never) the loop might run autonomously, with human oversight focused on strategic direction rather than individual changes.

The key enabler is verifiability. I trusted the loop this time because Cowork ran verification tests after the deploy and confirmed everything worked. As verification becomes more sophisticated—not just “does it compile?” but “is the user experience better?”—the loop can tighten further.

What Comes Next

Every creative industry I’ve studied moves through the same phases: pioneers, engineers, creators. In Software’s Creator Era Has Arrived, I described how software itself is undergoing that transition. What I’m describing here is what the creator era looks like in practice — not just humans creating software through AI, but AI agents creating improvements to their own tools through experiential feedback loops.

The LightCMS story is a small example. But small examples are how paradigm shifts begin. The first compiler was less efficient than hand-written assembly. The first web browser was less capable than native applications. The first AI-generated code was less reliable than human-written code. Each of these started as a curiosity and became the default.

I’ll be watching this loop closely: not just in my own workflow, but across the broader ecosystem. The frameworks are emerging (CrewAI, AutoGen, LangGraph). The protocols are in place (MCP for tool access, A2A for inter-agent collaboration). The models are getting better at sustained autonomous work. And the economic incentive is clear: if an operator agent can identify a bug that wastes 40% of its API calls, and a code agent can fix that bug in a single session, that’s a direct, measurable improvement in the cost of running the software.

Software, heal thyself...

It’s not a metaphor anymore.

Further Reading

My earlier writing on the creator era and agentic architecture:

• Software’s Creator Era Has Arrived: how the Pioneer→Engineering→Creator transition is hitting software itself.

• I Built a CMS for the Age of Agents: the LightCMS project and the idea of websites as conversations.

• The Agentic Web: Discovery, Commerce, and Creation: how agents are reshaping the web from pages to applications.

• The Age of Machine Societies Has Begun: autonomous agents collaborating, competing, and transacting.

• Composability is the Most Powerful Creative Force in the Universe: how aggregation, transmission, and iteration drive creativity from biology to software.

Multi-agent systems and self-improving software:

• Kenneth Reitz, "Strange Loops All the Way Down" (September 2025) — The recursive architecture of awareness, from DNA to consciousness to code. Part of his Consciousness and AI series.

• Multi-Agent Systems: overview on metavert.io of multi-agent architectures and frameworks.

• LightCMS on GitHub: the open-source CMS at the center of this story. MIT licensed.

• Arize AI, “Closing the Loop: Coding Agents, Telemetry, and the Path to Self-Improving Software” (February 2026) — Self-healing architectures and telemetry-driven improvement loops.

• Liu et al., “A Large-Scale Study on the Development and Issues of Multi-Agent AI Systems”: Comprehensive analysis of LLM-based multi-agent frameworks.

• Agyn: A Multi-Agent System for Team-Based Autonomous Code Generation: Role-based agent teams for autonomous software engineering.

• METR Benchmark (February 2026): AI agent autonomous task horizons reaching 14.5 hours, doubling every 123 days.

You can be the undisputed SEO champion for your category and remain completely invisible to the systems that a growing share of consumers actually trust for recommendations. And that share is growing fast—58% of consumers now rely on AI for product recommendations, more than double the rate from two years ago.

I wrote about this dynamic in The Agentic Web: Discovery, Commerce, and Creation, where I described the structural shift from traditional search to LLM-mediated discovery—and how it connects to the larger transformation of commerce, software creation, and the open web. That article laid out the research. This one is about what to do about it.

As I wrote in the Agentic Web piece: when answers become applications: when discovery, evaluation, and action collapse into a single agentic flow—the question of whether an LLM recommends you becomes existential. It’s not just about visibility in a text response. It’s about whether your brand gets woven into the dynamic, composed experiences that agents build for users.

I’m sharing LLM Optimizer: a free, open-source AI visibility intelligence platform that measures how large language models perceive, cite, and recommend your brand, then gives you research-backed strategies to improve that visibility. It’s the tool I built to make the research actionable.

🔗 GitHub: github.com/jonradoff/llmopt 🔗 Hosted version: llmopt.metavert.io

The Problem: A Completely Different Signal Landscape

Traditional SEO optimizes for Google’s ranking algorithm: backlinks, domain authority, keyword density, page speed. The discipline emerging around AI visibility—called Generative Engine Optimization, or GEO—optimizes for something fundamentally different: the likelihood that a language model will cite, recommend, or surface your brand when answering a relevant question.

And the signals that drive LLM citations are only 12–18% correlated with traditional SEO signals. Domain authority and backlinks, the bedrock of SEO for two decades, barely register.

This isn’t a gradual evolution. It’s a parallel universe. Gartner forecasts a 25% drop in traditional search engine volume by 2026. AI search traffic converts at five times the rate of Google organic: 14.2% versus 2.8%. The people who find you through AI aren’t just browsing. They’re ready to act.

The question every marketer needs to answer is: are you visible in this new world?

What the Research Says

I’ve spent months synthesizing research from Princeton, Toronto, Ahrefs, and several other groups studying LLM citation behavior. The findings are striking — and they invert much of what the SEO industry has taught us for twenty years.

Quotability is king. Adding quotable statements from authoritative sources produces the single largest visibility improvement: +41% in LLM citations. Statistics provide +33%. Improving overall fluency and readability: +29%. Authoritative source references: +25%. Meanwhile, traditional keyword stuffing actually hurts your AI visibility by 9%. LLMs aren’t matching keywords; they’re evaluating whether your content is worth citing.

Earned media dominates. LLMs draw 72–92% of their citations from earned media: reviews, forum discussions, independent articles, YouTube videos. Only 18–27% comes from brand-owned content like your corporate website. This inverts the traditional content marketing playbook. In the LLM world, your reputation is shaped primarily by what others say about you.

YouTube is critical. YouTube appears in 16% of LLM answers: 40% more frequently than Reddit. And here’s the finding that surprised me most while building this: research shows that a 7-billion-parameter video model trained on high-quality YouTube transcripts outperformed a 72-billion-parameter model with lower-quality training data. The implication is stark: if your brand produces video content without accurate captions, you are invisible to the LLMs training on that content. No transcripts = no training signal = no recommendations. It’s a binary gate.

Freshness trumps authority. AI citations skew 25.7% newer than Google citations on average. Content freshness can shift AI recommendation positions by as many as 95 ranks. If you’re not publishing consistently, you’re fading from the AI’s memory.

Training data frequency compounds everything. The NanoKnow research (2026) found that LLM answer accuracy more than doubles as a brand’s training data frequency increases from rare (1–5 documents) to high-frequency (51+ documents). But the really interesting finding is the compounding effect: being present in training data and being retrievable via search provides a multiplicative advantage. This means the strategy isn’t just about optimizing your website — it’s about being present across enough sources that you cross the threshold where LLMs have internalized your brand as a concept worth recommending. Every earned media mention, every Reddit discussion, every YouTube video with good transcripts contributes to that critical mass.

The playing field has reset. Sites that rank fifth on Google see a +115% improvement from GEO optimization. Sites that rank first actually see a −30% effect — because the competitive landscape is completely reshuffled. For challenger brands and solopreneurs, this is extraordinarily good news. The democratization effect is real: the twenty-year head start that established brands built through SEO doesn’t transfer to the new world. The advantage goes to whoever understands these dynamics first.

Different LLMs, different realities. One finding that informed LLM Optimizer’s multi-provider testing: citation concentration varies dramatically across providers. The top 20 news sources capture between 28% and 67% of all AI citations, depending on which LLM you’re asking. Cross-family similarity between providers ranges from just 0.11 to 0.58. In plain English: being visible on ChatGPT tells you almost nothing about whether you’re visible on Claude or Gemini. You have to test across all of them.

What LLM Optimizer Does

LLM Optimizer analyzes your brand across five dimensions, each grounded in the peer-reviewed research above, and produces a composite AI Visibility Score (0–100) with prioritized, actionable recommendations.

Answer Engine Optimization analyzes your website’s content against the strategies validated by the GEO research. It scores pages on quotation density, statistical evidence, source citations, fluency, structural optimization, and machine readability; it then produces per-page optimization scores with specific rewrite recommendations.

Video Authority Analysis performs a two-phase assessment of your YouTube presence. Phase 1 uses a fast model to assess individual videos for transcript quality, keyword alignment, and caption availability. Phase 2 feeds those assessments into a reasoning model for four-pillar scoring: Transcript Authority, Topical Dominance, Citation Network, and Brand Narrative.

Reddit Authority Analysis scrapes Reddit discussions mentioning your brand and analyzes community sentiment, competitive positioning, and training data signal strength. Because what your community says about you has 4–6× more influence on LLM recommendations than anything on your own website.

Search Visibility Analysis evaluates your site across both Google AI Overviews and standalone LLMs. It checks robots.txt AI crawler policies, structured data, content freshness, brand search momentum, and earned media signals.

LLM Knowledge Testing directly queries multiple LLM providers (Claude, ChatGPT, Gemini, and Grok) with your brand’s target queries and analyzes how each model responds. You can see exactly how each AI perceives your brand, compare your presence across providers, and run head-to-head competitor comparisons. Each LLM has substantially different citation behavior (cross-family similarity ranges from just 0.11 to 0.58), so testing across all four reveals blind spots you’d never find with a single provider.

All five dimensions aggregate into a Brand Intelligence report: a composite score weighted across Optimization (30%), Video Authority (20%), Reddit Authority (20%), Search Visibility (15%), and LLM Testing (15%). The weighting reflects the research: your site content is the foundation, but earned media signals (YouTube and Reddit) collectively outweigh it. The report generates prioritized action items that track through to completion — not vague advice like “improve your content,” but specific, evidence-based recommendations tied to the signals that actually move LLM citation behavior.

You can also generate PDF reports for sharing with stakeholders or clients: useful if you’re an agency or consultant helping brands navigate this transition.

Agentic by Design

If you’ve been following my open source projects, you know I’ve been building a set of open-source tools designed for the way software is actually being made and used right now: through conversations with AI agents. LightCMS manages my metavert.io through natural language. LastSaaS provides the SaaS infrastructure underneath. LLM Optimizer is the latest piece: I use it alongside LightCMS to analyze my own site’s AI visibility, identify gaps, then have agents implement the improvements directly. The whole workflow—analysis, recommendations, implementation—happens through conversation.

LLM Optimizer includes a full MCP server (Model Context Protocol, with OAuth 2.1 and Streamable HTTP transport) so AI assistants like Claude can access your analysis data, visibility scores, and action items programmatically. A marketer using Cowork or Claude Desktop can connect to LLM Optimizer and work through the to-do list: “What’s my current visibility score? What should I improve first? Draft the content changes.” The tool becomes part of the agent’s workflow rather than a separate dashboard you have to remember to check.

This is what I mean when I talk about the agentic web. The answer isn’t just a page of text anymore — it’s a dynamic experience that acts on your behalf. Your marketing tools should work the same way.

How to Use It

Bring your own API keys. At minimum, you’ll need an Anthropic API key; it powers the analysis engine. For the full picture, add OpenAI, Gemini, and Grok keys so you can test your visibility across all four major LLMs and see how each one perceives your brand differently. A YouTube Data API key unlocks the video authority analysis.

You have two options:

Use the hosted version at llmopt.metavert.io. Bring your API keys, pay a small subscription fee to support development and hosting, and you’re running analyses in minutes.

Self-host it. Clone the repo from GitHub, set up MongoDB, add your API keys, and run it yourself. It’s MIT licensed: no restrictions, no catch. The backend is Go, the frontend is React 19 with TypeScript, and it deploys cleanly on Fly.io or anywhere else you host containers.

git clone https://github.com/jonradoff/llmopt.git
cd llmopt && cp .env.dev.example .env
# Add your API keys to .env
cd backend && go build -o llmopt . && ./llmopt

The README walks through every step for both standalone and SaaS deployment modes.

For the technical folks: the backend is Go 1.24 with a clean LLM provider abstraction that supports Anthropic, OpenAI, Gemini, and Grok through a common interface. Each analysis streams results via SSE so you see progress in real time. The frontend is React 19 with TypeScript and Tailwind. MongoDB for storage. Cloudflare WARP integrated as a SOCKS5 proxy fallback for Reddit scraping. The codebase is structured the same way I structure all my recent projects — consistent patterns, clear separation of concerns, designed so that AI coding agents can navigate and extend it fluently. Fork it and make it yours.

The Bigger Picture

The shift I described in The Agentic Web is accelerating. Discovery is migrating from search engines to language models. Commerce is following. The signals that determine whether you get recommended are fundamentally different from the signals you’ve been optimizing for.

This is a rare moment where the competitive landscape genuinely resets. The incumbents who dominated Google don’t automatically dominate AI recommendations. The SEO playbook that worked for twenty years doesn’t transfer. The advantage goes to whoever understands the new rules first and adapts their content strategy accordingly.

LLM Optimizer is my attempt to make that adaptation measurable and actionable — grounded in the best available research, open-source so anyone can use and extend it, and designed for the agentic workflows that are becoming the default way we build and market.

I’ve been saying for a while that the constraint for today’s entrepreneur isn’t engineering capability: it’s imagination.

The same principle applies to marketing in the age of AI discovery. The constraint isn’t budget or team size. It’s understanding the new rules of the game. The research exists. The tools exist. The question is whether you act on them before your competitors do.

The research and scoring methodology that inform this tool are documented in detail in the LLM Visibility Research Summary. I’d encourage anyone navigating this shift to dig in. The more people who understand these dynamics, the better the ecosystem gets for everyone building on the open web.

The playing field has reset. Time to play.

Subscribe now

Further Reading

• The Agentic Web: Discovery, Commerce, and Creation: The full research deep-dive on LLM-mediated discovery, agentic commerce, and web-native creation — Part 3 of the Web Renaissance series.

• Software’s Creator Era Has Arrived: How AI agents are democratizing software development — the thesis behind why solo founders can now build tools like this.

• I Built a CMS for the Age of Agents: LightCMS — the AI-native content management system I use alongside LLM Optimizer.

• The Last SaaS Boilerplate: LastSaaS — the open-source SaaS foundation that LLM Optimizer is built on.

• Enshittification and the Future of AI Agents: The platform decay cycle and why open-source, agent-native tools are the escape hatch.

Tools and Research

• 🔗 LLM Optimizer on GitHub — MIT licensed, free

• 🔗 LLM Optimizer hosted — Bring your API keys

• 📄 GEO: Generative Engine Optimization (Princeton/KDD 2024)

• 📄 NanoKnow (2026) — Training data frequency and LLM accuracy

• 📄 AI Search Arena (2025) — Cross-provider citation analysis

Here’s a question that should keep every marketer and product manager awake at night: if 58% of consumers now rely on AI for product recommendations—more than double the rate from two years ago—and 93% of those AI search sessions end without a single click to a website… who controls the top of your funnel?

Not Google. Not anymore; at least, not exclusively.

The answer is increasingly: large language models. ChatGPT, Perplexity, Claude, Gemini. These systems don’t show you ten blue links. They answer.

But even that word—“answer”—already undersells what’s happening. These systems don’t just produce text anymore. They use tools. They browse, they synthesize, they compose. Ask Perplexity Computer to help you evaluate running shoes and it doesn’t just list options: it builds you an interactive comparison dashboard, pulls real-time pricing, and links to purchase. Ask Claude to analyze your market positioning and it generates a live application with charts you can manipulate.

The “answer” has become an experience that you interact with dynamically.

And this is the thread I want you to hold onto as you read this article: the unit of interaction on the web is shifting from pages to applications, from static content to dynamic composition, from things you read to things that act on your behalf.

Multimodality used to mean text plus images plus audio. Now it means answers that take the form of tools, dashboards, agents, and transactions. The agentic web doesn’t just serve information. It synthesizes, composes, and acts. It does so on a substrate that is uniquely suited to this kind of dynamic creation: the open web.

When I spoke with Aravind Srinivas back in 2023—before Perplexity had become a household name—he described a clear arc: we went from libraries to Google to answer engines, each step eliminating a layer of manual labor between the question and the knowledge. He called what Perplexity was building “dynamic personalized Wikipedia pages.” But even that framing assumed the answer would still be a page. What’s happened since is that the answer broke free of the page entirely. It became an application, a tool, an agent that acts.

This is the world I hinted at two years ago in Part 1 and Part 2 of this series, when I wrote about the Great Rebundling and how the web could eat software. I described a future where LLMs reorganized discovery away from ad-driven intermediaries, where WebGPU closed the performance gap between browsers and native apps, and where the web reasserted itself as the open, composable platform it was always meant to be.

It took a while for me to finally write this Part 3. But the wait was worth it: because the changes that have landed in the last two years are not incremental. They’re structural. Three forces have converged—a revolution in how people discover brands and products through AI, a new payments infrastructure built for agents to transact on behalf of humans (and each other), and a dramatic expansion of who can build for the web and what they can build. Together, they amount to something I can only describe as the agentic web.

The Quick WebGPU Update

First, a loose end from Part 2. When I wrote about WebGPU in 2024, it was a Chrome-only affair—impressive in potential, limited in reach. The question was whether Firefox and Safari would follow.

They did—mostly. As of late 2025, WebGPU ships by default in Chrome, Edge, Firefox (since version 141 in July 2025), and Safari on macOS Tahoe and visionOS. Apple announced full WebGPU support in Safari 26, including iOS 26 and iPadOS 26, which means mobile Safari is finally getting GPU-accelerated web capabilities; though as of this writing, iOS 26 is still in beta and hasn’t shipped to the general public. Apple being Apple, the mobile rollout is happening on their timeline, not ours. But the commitment is real: WebGPU supersedes WebGL on all Apple platforms, mapping directly to Metal. Babylon.js, Three.js, Unity, PlayCanvas, TensorFlow.js, and ONNX Runtime all work in Safari 26 beta. When iOS 26 ships broadly later this year, WebGPU will have effectively universal desktop and mobile browser coverage.

The significance of this is not just that browsers can render prettier graphics. It’s that one of desktop software’s last remaining advantages (high-performance GPU access for 3D rendering, AI inference, and immersive experiences) is now accessible through a URL. No download, no install, no app store. We’ll return to why this matters when we talk about web development later.

The New Top of the Funnel

But first, let me introduce the force that I think matters most for anyone reading this who builds products, runs a business, or markets anything online.

The way people discover things has fundamentally changed.

In Part 1, I described how search evolved from web directories to Google to LLM-powered answer engines, each transition driven by the same principle: whoever gives you better answers faster wins. That prediction has played out more aggressively than even I expected. Gartner now forecasts a 25% drop in traditional search engine volume by 2026, and AI search traffic converts at five times the rate of Google organic — 14.2% versus 2.8%. That’s not a rounding error. That’s a structural shift in the economics of attention.

What makes this especially interesting is that AI-powered discovery operates on an almost entirely different signal landscape than traditional search. Research from Princeton and Toronto shows only a 12–15% overlap between URLs that rank in Google’s top 100 and those cited by ChatGPT or Perplexity for the same queries. Eighty percent of the URLs cited by major LLMs don’t appear in Google’s top 100 at all. You can be the undisputed SEO champion for your category and remain completely invisible to the systems that a growing share of consumers actually trust for recommendations.

I’ll go much deeper on what to do about this later in this article. For now, understand that this is the new reality of the top of the funnel: LLMs are the gatekeepers, and they play by different rules.

Commerce Breaks Free

Before we talk about agents buying things, let’s talk about the structural shift that made it possible: the migration of digital commerce away from app stores and toward the open web.

The numbers here are striking and immediate. According to Matthew Ball’s State of Video Gaming in 2026 report, some top game publishers now generate 30–50% of player spend through direct-to-consumer channels.

Forty percent of the top 100 mobile games use web shops. The economics are obvious: most webshop providers charge roughly 5% of revenue versus the 30% extracted by Apple and Google. Epic Games launched its webshop infrastructure in mid-2025, offering developers a 0% revenue share on their first million dollars per app, and only 12% above that. Xsolla, a longstanding payments platform for games, has built dedicated mobile webshop tooling that lets developers stand up their own storefronts.

The legal landscape accelerated this. Court rulings in the United States (most notably the litigation between Epic and Apple) have opened the door for developers to direct users to out-of-app purchase options on iOS. The European Union’s Digital Markets Act pushed even further. These aren’t abstract policy debates; they’re the “why now” behind a wave of webshop adoption that has shifted from experimental to strategic.

This resonates with something I highlighted in Enshittification and the Future of AI Agents: the three-stage decay of platforms that attract users, habituate them, then extract from them. App stores followed this playbook perfectly. The web is the escape hatch. And now agents are driving through it, which brings us to the bigger story.

It’s worth noting that not every creator-friendly platform is purely open web. Roblox (which launches from browsers) paid creators over $1 billion in 2025, and now reaches 144 million daily active users, operates more like a walled garden built on web-native principles. But Roblox is being pulled into the agentic orbit: they recently shipped an open-source MCP server (Model Context Protocol, which I expand on below) that lets Claude modify Roblox experiences directly from natural language prompts. When even the platforms that could stay closed are adopting open agentic protocols, it tells you something about the direction of gravity.

Agentic Commerce: When Agents Start Buying

If the “answer” is becoming an application—dynamic, composable experience rather than a block of text—then commerce is the natural next frontier. Discovery, evaluation, and purchase collapse into a single agentic flow. An agent doesn’t just recommend running shoes; it builds you a comparison tool, surfaces real-time inventory, and completes the transaction.

The question isn’t whether AI agents will start purchasing on behalf of users. It’s how fast the infrastructure can keep up.

Faster than you’d think. McKinsey estimates that AI agents could mediate $3 to $5 trillion in global consumer commerce by 2030, with as much as $1 trillion in the U.S. alone.

Tooling has already arrived: OpenClaw—the open-source personal AI agent that exploded to over 145,000 GitHub stars within two weeks of its January 2026 launch—has been called the “Napster moment” for agentic e-commerce. Users are having it plan trips end-to-end: it checks loyalty points, digs up a corporate rate it found buried in an old PDF in your email, books the flight, and completes payment with a virtual card. Others have it generating sorted grocery lists from recipe screenshots, comparing prices across local stores, and placing the order. It runs locally, it’s MIT-licensed, and the community extends its skill library daily.

Then there’s Perplexity Computer, launched in February 2026, which orchestrates 19 models in parallel and connects to hundreds of third-party services—Gmail, Slack, Notion, GitHub, Jira, FactSet—functioning as what many are calling the mass-market successor to OpenClaw’s developer-centric approach.² These aren’t demos. These are people composing entire purchase workflows.

Discovery, evaluation, transaction.

…into a single agentic flow, exactly the answers-as-applications pattern playing out in commerce.

The Protocol Stack

The payments infrastructure is keeping pace. The Agentic Commerce Protocol (ACP), co-developed by Stripe and OpenAI, allows users to complete purchases within ChatGPT without ever leaving the conversation. Businesses connect their product catalogs to Stripe’s agentic commerce suite, which creates agent-readable endpoints with real-time product, pricing, and availability data. When an agent finds what you’re looking for, it generates a Shared Payment Token that is scoped to a specific seller, bounded by time and amount, and monitored by Stripe’s fraud detection. Major brands like URBN, Etsy, Coach, and Ashley Furniture are already onboarding.

Then there’s x402, which takes a more radical path: baking payments directly into HTTP itself. When a client (human or agent) requests a paid resource, the server responds with HTTP status code 402 (the “Payment Required” status that has existed in the spec since the early web but was never implemented). The client pays using stablecoins, instantly and with essentially zero fees. No accounts, no API keys, no subscriptions. Just money moving at the speed of a web request.⁴

Parallel to both sits a layer that’s easy to overlook but critical to the whole stack: Anthropic’s Model Context Protocol (MCP). If ACP and x402 define how agents pay, MCP defines how agents connect—to merchant systems, payment processors, inventory databases, enterprise backends. Anthropic open-sourced it in late 2024, it now has over 10,000 active servers and 97 million monthly SDK downloads, and in December 2025 they donated it to the Linux Foundation’s Agentic AI Foundation, co-founded with Block and OpenAI. To see what this looks like in practice: Worldpay built their agentic payments integration directly on MCP. Walmart built a “Super Agent” architecture on MCP where a customer can say “plan a unicorn-themed birthday party for 8 kids” and the agent pulls from party supplies, bakery, and invitations simultaneously: a single composed experience spanning multiple inventory systems. Visa and Mastercard have launched their own agentic AI payment tools. The infrastructure is real.

It’s worth noting that MCP isn’t the only connectivity protocol in play. Google’s A2A (Agent-to-Agent) protocol handles inter-agent collaboration, and there’s a growing ecosystem of complementary standards. But MCP has won the adoption race so far — 10,000+ servers versus roughly 50 A2A partners, largely because it solved the most immediate problem first: giving agents a standardized way to access tools and data, the equivalent of a USB-C port for AI applications. As even Sam Altman put it when OpenAI announced MCP support: “People love MCP.” The protocols are complementary, not competitive: MCP for tool access, A2A for cross-organizational collaboration, but MCP’s head start matters.⁵

As I wrote in The Age of Machine Societies, autonomous agents are already demonstrating genuine cooperative and competitive behaviors — collaborating to solve complex tasks, forming alliances, even launching their own token economies. Tools like OpenClaw and Perplexity Computer are making agent-mediated action accessible to ordinary users; ACP and x402 are making agent-mediated transactions possible at scale; and MCP provides the connective tissue that lets agents actually navigate merchant infrastructure. Together, they’re building the commerce layer that machine societies will transact on.¹

The Web Is Getting Easier to Build

There’s a reason the web is winning this battle, and it’s not just that the fees are lower. It’s that the web is becoming dramatically easier to build for. The tools doing the building are overwhelmingly targeting the web as their default output surface.

Remember that shift from answers-as-text to answers-as-applications? This is where it becomes concrete. When an LLM’s response to your question is a fully functional web app, the web isn’t just a distribution channel: it’s the medium of thought for AI systems.

Consider the numbers: 41% of all code written globally is now AI-generated. Ninety-two percent of U.S. developers use AI coding tools daily. Twenty-one percent of Y Combinator’s Winter 2025 startups shipped codebases that are 91% or more AI-generated. The vibe coding platform market hit $4.7 billion and is projected to reach $12.3 billion by 2027.

And what are all these tools building? Web apps. HTML, React, and Node are the default output targets for virtually every agentic coding platform: from Cursor and Bolt to Claude Code and Perplexity Computer. Perplexity Computer is especially interesting here: it orchestrates 19 models in parallel, has connectors to hundreds of web-native data providers, and outputs fully functional web applications. When I used it to create an agentic marketer for LastSaaS—and separately, a real-time investments dashboard with thesis analysis and scenario simulation—I described what I wanted in plain language and got back fully functional web applications: interactive charts, real-time data connectors, responsive layouts. No build step, no compilation, no App Store review. Just URLs. These weren’t “answers” in any traditional sense; they were bespoke software applications, composed on the fly, deployed to the web instantly. That’s the new multimodality: not text plus images, but answers that take the form of interactive tools.

This is a point I’ve made before — first in Semantic Programming and Software 2.0, and more recently in Software’s Creator Era Has Arrived, where I argued that software is undergoing the same Pioneer→Engineering→Creator transition that transformed media, music, and games. Language models are becoming a compiler for natural language. What’s happened since is that this compiler got much better, and the output format it prefers is overwhelmingly web-native. The web is the universal deployment target because it requires no gatekeepers, no installation, and no platform-specific adaptation. An agent can generate a complete application and make it available to anyone with a browser in a single step.

And here’s where it comes together: the same agentic layer that makes software easier to build is the one that diminishes the gravitational pull of incumbent platforms. Yes, Gmail and Google Calendar probably only get stronger in a world where AI agents orchestrate everything: they’re deeply embedded data providers with robust APIs.

What erodes is the bundling advantage: the lock-in that kept users inside a single vendor’s ecosystem because switching costs were too high and interoperability too painful. When agents can seamlessly weave together data from any web-native source—pulling your calendar from Google, your tasks from Notion, your email from wherever, your analytics from a dashboard you built last Tuesday—the value shifts from the platforms that hoard your data to the agents that orchestrate it. As I detailed in Composability Is the Most Powerful Creative Force in the Universe, the most powerful systems emerge from interoperable primitives. The open web is the ultimate composable substrate. That’s a web renaissance by any definition.

With WebGPU now shipping across all major browsers, even the last stronghold of desktop-only software—high-performance 3D graphics and GPU-accelerated computation—is accessible through the browser. As game engines and creative tools adopt WebGPU, the case for requiring a download shrinks further. The web won’t replace AAA game engines overnight, but the trajectory is clear: more and more of what required a native application can be delivered through a URL.

The Deep Dive: Winning in an LLM-First World

Now let me return to what I promised: a deeper look at what the shift to LLM-mediated discovery actually means for how you build, market, and grow a business on the agentic web. And keep in mind the thread we’ve been following: when answers are applications—when discovery, evaluation, and action collapse into a single agentic flow—the question of whether an LLM recommends you becomes existential. It’s not just about visibility in a text response. It’s about whether your brand gets woven into the dynamic, composed experiences that agents build for users.

The discipline emerging around this is called Generative Engine Optimization (GEO) and it represents a genuinely new category of marketing practice. Not SEO (search engine optimization) with a new acronym. A fundamentally different optimization problem.

Here’s why. Traditional SEO optimizes for Google’s ranking algorithm: backlinks, domain authority, keyword density, page speed. GEO optimizes for something different entirely: the likelihood that a language model will cite, recommend, or surface your brand when answering a relevant question. And the signals that drive LLM citations are only 12–18% correlated with traditional SEO signals. Domain authority and backlinks, the bedrock of SEO for two decades, barely register.

What does matter? Research from Princeton’s GEO study, the Toronto GEO 2025 paper, and my own work building LLM Optimizer (an open-source project I’m testing to improve brand visibility across AI discovery channels) tells a clear story:

Quotability is king. Adding quotable statements from authoritative sources produces the single largest visibility improvement: +41% in LLM citations. Statistics provide +33%. Improving overall fluency and readability: +29%. Authoritative source references: +25%. Meanwhile, traditional keyword stuffing — the junk-food of SEO — actually hurts your AI visibility by 9%. LLMs aren’t matching keywords; they’re evaluating whether your content is worth citing.

Earned media dominates. LLMs draw 72–92% of their citations from earned media: reviews, forum discussions, independent articles, YouTube videos. Only 18–27% comes from brand-owned content like your corporate website. This inverts the traditional content marketing playbook, where you control the narrative on your own domain. In the LLM world, your reputation is shaped primarily by what others say about you — especially on platforms like YouTube (which appears in 16% of LLM answers, 40% more frequently than Reddit) and community forums.

The democratization effect is real. Sites that rank fifth on Google see a +115% improvement from GEO optimization. Sites that rank first actually see a −30% effect — because the competitive landscape is completely reshuffled. For challenger brands and solopreneurs, this is extraordinarily good news: the playing field has reset, and the advantage goes to those who understand the new rules first.

Freshness matters more than authority. AI citations skew 25.7% newer than Google citations on average. Content freshness changes can shift AI recommendation positions by as many as 95 ranks. If you’re not publishing consistently, you’re fading from the AI’s memory.

I’ve been hacking together LLM Optimizer to make these dynamics measurable and actionable. It’s an app I’m currently testing with early users that analyzes your brand across five dimensions: site content optimization, video authority (YouTube), Reddit presence, search visibility, and direct LLM testing across Claude, ChatGPT, Gemini, and Grok—and produces a composite visibility score with specific, evidence-based recommendations.³

The five-dimensional framework behind LLM Optimizer’s composite visibility score.

It’s in active development and I’d encourage anyone navigating this shift to take a look. I’ll have a more detailed writeup on the tool and its methodology soon — the research and scoring framework I’ve built into it informed much of this article’s analysis.

The Agentic Web

Step back and look at what’s happening in aggregate.

An answer used to be a page of text. Then it became a page of links. Then a snippet at the top of a search result. Now it’s becoming something entirely different: a dynamically composed experience: part information, part application, part agent. It doesn’t just tell you something but does something. It builds you a dashboard. It compares prices across vendors and completes the purchase. It generates a tool you can interact with, share, and build upon.

And where does this happen? On the web. Not in an app store. Not inside a walled garden. On the open, composable, URL-addressable web: the only medium flexible enough to serve as both the canvas and the runtime for this kind of dynamic creation.

The protocols agents transact on (ACP, x402, MCP) are web-native. The software they build targets the browser by default. The content they cite follows a different logic than the platform algorithms we’ve spent two decades optimizing for. The GPU capabilities that once kept high-end experiences locked inside native apps are now available through a URL. The web isn’t just surviving the agentic era. It’s the substrate of the agentic era.

What I described in Part 1 as the Great Rebundling is now playing out across every dimension of online activity. The intermediaries haven’t disappeared; they’ve changed form.

Instead of Google organizing the world’s information behind a wall of ads, or Apple extracting rent on every digital transaction through a locked-down app store, we’re seeing a new architecture emerge: one where AI agents navigate the open web on your behalf, compose services from whatever sources serve you best, and transact using protocols that don’t extract 30% for the privilege of existing.

For entrepreneurs, solopreneurs, and product builders, the implications are practical and immediate. Your marketing funnel now starts with whether an LLM recommends you, and increasingly, whether it weaves your product into the applications it composes for users. Optimize for that. Your distribution strategy should favor the web over app stores wherever possible: the economics are better and the barriers to entry are lower.

Your development velocity should take advantage of agentic tools that can spin up web applications from natural language descriptions. And your content strategy should prioritize earning citations from the sources that LLMs actually trust: community discussions, independent reviews, expert commentary, and YouTube.

The web was always supposed to be open, composable, and accessible. For a long time, the dominant platforms pulled it in the opposite direction: toward walled gardens, toward rent-seeking intermediaries, toward the enshittification cycle.

The agentic web is a correction. Not a utopia; there are real concerns about AI accuracy, about the concentration of power in foundation model providers, about security in multi-agent systems. But the direction is unmistakable: agents prefer the open web because it’s the medium that lets them compose freely. And as they compose, they’re transforming not just the web but the very nature of what it means to search, to discover, to build, and to transact online.

The answer is no longer a page. It’s an experience. And the web is where experiences get made.

The renaissance continues.

Subscribe now

Further Reading

This series:
Web Renaissance, Part 1: The Great Rebundling
Web Renaissance, Part 2: How the Web Eats Software

Related articles by me:

• The State of AI Agents in 2026: 200+ slide research deck on agentic engineering

• Software’s Creator Era Has Arrived: how AI agents are democratizing software development

• Semantic Programming and Software 2.0: language models as compilers for natural language

• Composability Is the Most Powerful Creative Force in the Universe: why interoperable primitives beat monolithic solutions

• The Age of Machine Societies: autonomous agents collaborating, competing, and transacting

• Enshittification and the Future of AI Agents: the platform decay cycle and the agentic escape hatch

Tools and technology:

• LLM Optimizer: Analyze and improve your brand’s AI discovery visibility

• Stripe Agentic Commerce Suite — Infrastructure for agent-mediated transactions

• x402 Protocol — Internet-native micropayments via HTTP 402

• Agentic Commerce Protocol (ACP) — Open spec for agent-to-merchant commerce

• Model Context Protocol (MCP) — The connective tissue for agentic systems
  OpenClaw — Open-source personal AI agent

• Perplexity Computer — Multi-model agentic platform

• Jon Radoff interviews Aravind Srinivas (2023) — The conversation that prefigured much of this article

Key research sources cited:

• McKinsey: The Agentic Commerce Opportunity

• Matthew Ball / Epyllion: State of Video Gaming 2026

• GEO: Generative Engine Optimization (Princeton, 2024), a foundational paper on optimizing content for LLM citation

• NanoKnow (2026): how training data frequency predicts LLM answer accuracy

¹ The complementarity between ACP and x402 mirrors a pattern I explored in Composability Is the Most Powerful Creative Force in the Universe: the most powerful systems are built from interoperable primitives rather than monolithic solutions. Payments on the agentic web will likely use both protocols depending on the transaction type, just as the web itself uses HTTP, WebSockets, and WebRTC for different communication patterns.

² The contrast between OpenClaw and Perplexity Computer is instructive. OpenClaw is developer-first: open source, local-first, extensible through community skills, running on your machine with full system access. Perplexity Computer is consumer-first: hosted, managed, 19-model orchestration, hundreds of pre-built connectors, $200/month. This mirrors the classic open-vs-managed split in every infrastructure category (and both are winning, because the real competitor is doing nothing). Galaxy Research estimates that agent-mediated transactions could represent a meaningful fraction of all internet commerce within five years, and that’s a large enough market for many approaches to coexist.

³ One finding from building LLM Optimizer that surprised me: YouTube transcripts are disproportionately powerful for LLM training. Research shows that 7-billion-parameter video models trained on high-quality YouTube transcripts outperform 72-billion-parameter models with lower-quality training data. The implication is stark — if your brand produces video content without accurate captions, you are invisible to the LLMs that are training on that content. No transcripts = no training signal = no recommendations. It’s a binary gate that most brands haven’t yet grasped.

⁴ The HTTP 402 “Payment Required” status code has existed in the HTTP specification since 1997 and reserved for future use but never implemented. It took nearly three decades and the arrival of autonomous AI agents to finally give it a purpose. There’s something poetic about the web’s original architects leaving a placeholder for machine-native payments, and a generation of AI engineers finally filling it in. For more on x402’s technical architecture, see the x402 protocol documentation and Galaxy’s analysis of its implications for AI agent economies.

⁵ The protocol landscape for agentic systems is worth watching closely. MCP (tool access), A2A (agent-to-agent collaboration), ACP (commerce transactions), and Google’s UCP (Universal Commerce Protocol) each address different layers of the stack. What’s interesting is that they’re converging on complementary roles rather than competing head-to-head, much like how HTTP, TCP, and DNS each handle different layers of the web itself. MCP’s early dominance mirrors how USB-C won: solve the most common connection problem first, then let the ecosystem build on top. The fact that Anthropic donated MCP to the Linux Foundation (with OpenAI, Google, Microsoft, and AWS as supporters) signals that this is infrastructure, not product strategy.

That era is over.

Subscribe now

AI agents have collapsed the gap between a founder’s vision and production software. I’ve been building at this intersection: shipping real products through conversations with AI coding agents, writing about what I’ve called the shift from the Engineering Era to the Creator Era—and I reached a point where the biggest remaining friction wasn’t the AI. It was the starting point. Every new SaaS project still required rebuilding the same foundational infrastructure from scratch, or paying hundreds of dollars for a boilerplate that was missing half of what a production product actually needs.

So I built LastSaaS. It’s a complete, production-ready SaaS foundation: authentication, billing, multi-tenancy, white-labeling, webhooks, admin dashboards, health monitoring — built on a modern Go and React stack, designed from the ground up to be extended by you and your AI agents. It’s free. MIT licensed. No catch.

I want to tell you what it does, how it works, and why I think it represents something much larger than a boilerplate.

You no longer need a team to launch a SaaS business

Here’s what changed. A solo founder with a clear product vision can now do what once required a ten-person startup. AI coding agents — Claude Code, Cursor, Copilot — handle the engineering. Cloud infrastructure handles the scaling. The only piece that was still missing was the starting point: a production-grade SaaS foundation that doesn’t cost hundreds of dollars, doesn’t lock you into a single JavaScript framework, and doesn’t fall apart the moment you need real multi-tenancy or webhook infrastructure.

The existing market tried to solve this with paid boilerplates: ShipFast ($199), Supastarter ($349–399), MakerKit ($199–599), SaaSRock ($117+), SaaS Pegasus ($249+), Shipped.club ($157), LaunchFast ($99–249). Some are decent. Most cover authentication and Stripe integration. A few support multi-tenancy.

But I evaluated every one of them and kept hitting the same wall. They charge licensing fees for commodity infrastructure. They lock you into specific frameworks (almost always Next.js). Most lack the features a real production SaaS needs: proper webhook systems, white-label capabilities, health monitoring, API key management. And none of them were built for the way software is actually being made right now: through conversations with AI agents, using modern stacks that AI tools navigate fluently.

The constraint for today’s entrepreneur isn’t engineering capability.

It’s imagination…

…knowing what to build and who to serve. LastSaaS eliminates the infrastructure tax so you can focus entirely on that.

What LastSaaS actually is

LastSaaS is a production-grade SaaS foundation built on Go 1.25 and React 19 with TypeScript. I chose this stack deliberately: Go gives you the performance characteristics and deployment simplicity that a backend demands; React 19 with Vite 7 and Tailwind CSS 4 gives you a modern, component-based frontend that AI agents navigate fluently.

Here’s what you get on day one:

Authentication and identity. OAuth integrations for Google, GitHub, and Microsoft. Magic link passwordless authentication. TOTP multi-factor authentication with recovery codes. JWT token management with refresh rotation. Email verification. This isn’t a toy auth system. It’s the same security infrastructure you’d build if you had six months and a dedicated security team.

Billing and monetization. Full Stripe integration supporting subscription billing, per-seat pricing models, free trial management, and a credit-based usage tracking system. Invoice generation. Tax handling. Financial dashboards that give you operational visibility from day one. Credit bundle purchases for consumption-based models.

True multi-tenancy. Three-tier role-based access control: owner, admin, user — with tenant isolation. Team management and invitations. Ownership transfer.

White-labeling. Custom domain support. A theme engine for logos, colors, and visual identity. Custom CSS injection. Configurable navigation. Landing page customization. Your customers’ customers never see your brand unless you want them to.

API ecosystem. Scoped API keys with granular permissions. Nineteen outgoing webhook event types with HMAC-signed payloads for security. Webhook management and delivery tracking with retry logic. This is the kind of API infrastructure that separates a real platform from a demo project.

Operations and admin. A comprehensive admin dashboard. System health monitoring with eight visualization charts. User impersonation for support and debugging. CLI utilities for management tasks.

For the technical founders: how it works under the hood

I want to take a moment for the engineers and technical founders reading this, because the architecture decisions matter and they reveal something about the philosophy.

Go on the backend was a deliberate choice. Not Node. Not Python. Go gives you compiled binaries with minimal runtime dependencies, trivial containerization, built-in concurrency through goroutines, and memory efficiency that means your $5/month Fly.io instance can handle real production traffic. The API layer uses gorilla/mux for routing — battle-tested, well-understood, and straightforward for agents to navigate.

React 19 with TypeScript on the frontend because the ecosystem is massive, the type safety catches errors before they ship, and every AI code generation tool on the planet has been trained extensively on React patterns. When you fork LastSaaS and tell Claude Code to add a new dashboard view, it knows exactly what to do.

MongoDB for data because document-oriented storage maps naturally to multi-tenant SaaS architectures. Each tenant’s data is structurally isolated without the complex row-level security policies that multi-tenant PostgreSQL demands. Document schemas flex as your product evolves, which matters enormously in early-stage SaaS where your data model changes weekly. You can run MongoDB Atlas for managed hosting or deploy locally; your choice, no vendor lock-in.

Security isn’t an afterthought. JWT refresh rotation prevents token theft from becoming permanent compromise. HMAC-signed webhooks ensure your integration partners can verify payloads. Content Security Policy headers, HSTS, rate limiting, and injection protection are baked in. TOTP MFA with recovery codes means your users’ accounts are protected by the same second-factor approach used by every serious SaaS.

The codebase follows consistent patterns specifically because AI agents need navigable, predictable code structure. Every handler follows the same shape. Every model follows the same conventions. This isn’t just good engineering practice — it’s an explicit design requirement for the agentic era.

Designed for agentic engineering

I’ve written extensively about the distinction between vibe coding and agentic engineering. Vibe coding is the casual, prompt-and-pray approach: you describe something to an AI and hope the output works. Agentic engineering is the professional practice of orchestrating AI agents within structured systems to produce reliable, production-quality software.

LastSaaS was built through agentic engineering — developed in conversations with Claude Code — and it’s designed to be extended the same way. This isn’t a marketing claim. It’s an architectural decision that permeates the codebase.

Three things make this concrete:

The MCP server. LastSaaS includes a built-in Model Context Protocol server that enables conversational management of your running application. Your AI agents can interact with the SaaS platform through natural language — querying tenant status, analyzing financial reports, monitoring health. This is operational infrastructure for machine societies, not a gimmick.

Fork-ready architecture. The consistent patterns, clear separation of concerns, and predictable code structure mean that when you fork LastSaaS and point an AI coding agent at it, the agent understands the codebase immediately. No onboarding period. No “figure out what the previous developer was thinking.” The code was written by an AI-human collaboration; it’s natively fluent for the next AI-human collaboration.

Scoped API keys. Your agents need programmatic access with least-privilege permissions. LastSaaS provides granular API key scoping so you can give an agent exactly the access it needs and nothing more. This is how responsible agentic systems are built.

The person with the idea can now be the person who ships it. LastSaaS removes the last structural barrier between imagination and a running SaaS business.

The competitive landscape

Let me be direct about how LastSaaS compares to the existing market. I evaluated these alternatives extensively before building this.

ShipFast ($199) is probably the most popular SaaS boilerplate right now, built by Marc Lou on Next.js. It’s well-marketed and covers the basics: auth, Stripe, email, SEO. But it lacks true multi-tenancy, has no webhook system, no white-labeling, and no MCP integration. For a landing page with auth and payments, it works. For a production SaaS platform, it’s insufficient.

Supastarter ($349–399) offers multi-framework support across Next.js, Nuxt, and SvelteKit, which is appealing. It includes multi-tenancy and seat-based billing. But there’s no webhook infrastructure, no white-label capabilities, and the agentic support is limited to Vercel’s AI SDK — useful for building AI features into your product, not for building withAI agents.

MakerKit ($199–599) provides solid auth, Stripe integration, and RBAC on Next.js. The Teams tier adds AI chatbot and writer plugins. But the webhook system is basic, there’s no white-labeling, and the premium features that differentiate it cost $599 — for code you’ll immediately need to modify.

Open SaaS (free) deserves mention as the only other serious free option. Built on the Wasp framework with React and Node.js, it’s gained 10,000+ GitHub stars and includes Claude integration. The limitation: it requires learning the Wasp framework, its multi-tenancy is basic, and it lacks the webhook, white-label, and operational monitoring infrastructure that production SaaS demands.

SaaS Pegasus ($249+) is the strongest competitor for AI-focused development, with built-in LLM agent support. But it’s Django/Python — a fine choice if you’re in that ecosystem, but Go’s performance and deployment characteristics are a generation ahead for API-heavy SaaS backends. And it’s not free.

Shipped.club ($157) and LaunchFast ($99–249) round out the paid market. Both cover authentication and payments on Next.js or multi-framework stacks. Neither offers multi-tenancy, webhooks, white-labeling, or agentic development support. They’re landing-page-to-payment pipelines, not SaaS platforms.

Here’s the pattern: every paid boilerplate charges you $100–600 for commodity infrastructure that’s missing critical production features. The free alternatives cover the basics but lack the depth needed for serious multi-tenant SaaS. LastSaaS delivers more features than any paid competitor—for free—and it’s the only one purpose-built for agentic engineering workflows.

What this represents

I’ve been tracking the evolution of creative industries through three eras: Pioneer, Engineering, Creator—for years. In the Pioneer Era, building a SaaS product required a large engineering team, months of infrastructure work, and significant capital. In the Engineering Era, paid boilerplates and frameworks reduced the timeline but introduced licensing costs and framework lock-in. The constraint shifted from ability to access.

The Creator Era eliminates both constraints. LastSaaS provides the infrastructure layer for free. AI agents provide the engineering capability. The only remaining bottleneck is the idea itself — the vision for what your SaaS product should be and who it should serve.

This is exactly the thesis I laid out in “Software’s Creator Era Has Arrived”—the gap between intention and implementation has collapsed. What used to require a founding team of engineers now requires a founder with clarity of vision and the ability to orchestrate AI agents. LastSaaS is the infrastructure layer that makes this real.

I built Flipbook, a live production SaaS—on this foundation (you can also just install Flipbook on your own machine and use it without SaaS, but I wanted to use it as a live production example). It works. It’s handling real users, real payments, real multi-tenant workloads. LastSaaS isn’t a proof of concept. It’s production infrastructure that’s already proven.

Get started

LastSaaS is live on GitHub under the MIT license. Clone it. Fork it. Tell your AI agent to customize it for your domain. Ship your SaaS.

🔗 GitHub: github.com/jonradoff/lastsaas

🔗 Learn more: metavert.io/lastsaas

The setup is straightforward: clone the repo, run the setup script, configure your environment variables for MongoDB, Stripe, and Resend, and you have a running SaaS platform. The README walks through every step. Docker containerization and Fly.io deployment are documented and tested.

The person with the idea can now be the person who ships it. The infrastructure is free. The agents are ready. The only question is what you’ll build.

Subscribe now

Further reading

Software’s Creator Era Has Arrived: The case for why the bottleneck in software has shifted from engineering to imagination, and what that means for who gets to build.

Semantic Programming and Software: Natural language as a programming language. The conceptual foundation for why agentic engineering works.

The Direct-from-Imagination Era Has Begun: The original essay on how creative tools evolve through Pioneer, Engineering, and Creator eras — and why software is following the same path.

Evolution of the Creator Economy: Where LastSaaS fits in the larger arc of how technology democratizes creative industries.

That bottleneck has moved.

I’ve spent the past several weeks compiling what became a 200+ slide research deck: The State of Agents & Agentic Engineering — 2026. It draws on earnings reports, benchmark data, academic research, and my own experience building agentic systems. What follows isn’t a summary of the deck—it’s what the research revealed when I stepped back and looked at the whole picture.

The full deck is on the State of AI Agents in 2026 is located here. Throughout this article, I’ll point to specific pages where you can dive deeper into the underlying data.

Subscribe now

1. The $211 Billion Question

In 2025, AI venture capital hit $211 billion—half of all global VC funding. Total AI spending reached $1.5 trillion. The SpaceX-xAI merger created the largest corporate combination in history at $1.25 trillion.

And yet: only 6% of organizations report more than 5% EBIT impact from AI (McKinsey, 2025).

That gap is the story. Not that AI doesn’t work—it does—but that most organizations haven’t figured out how to capture value from it. The outliers, however, are extraordinary: a 6x output gap between top-quartile AI users and everyone else. A 67% increase in merged pull requests per engineer at Anthropic. Autonomous task horizons that doubled from minutes to 14.5 hours in eighteen months.

The 6% is a snapshot of early adoption. The outliers show where the curve is heading—and that curve doubles every four months.

2. The Technology Crossed a Threshold

Here’s the shift that doesn’t get enough attention: AI inference costs dropped 92% in three years. Per-million-token pricing fell from $30 in early 2023 to $0.10-$2.50 in February 2026.

That’s not an incremental improvement. That’s a phase transition.

When I wrote about the Direct from Imagination era, I described a future where people would speak entire worlds into existence. The enabling condition for that future isn’t just model intelligence—it’s model economics. At $30 per million tokens, agentic workflows are a luxury. At $0.10, they’re table stakes.

Meanwhile, the benchmarks tell their own story. Claude Opus 4.5 hit 80.9% on SWE-Bench Verified—up from 33% just eighteen months ago. On GPQA Diamond, which measures PhD-level scientific reasoning, Claude Opus 4.6 scored 91.3%, exceeding human experts at 69.7% by over 21 points.

But the most consequential benchmark might be the one METR publishes on task horizons. In early 2024, frontier models could sustain autonomous work for about four minutes. By February 2026, Claude Opus 4.6 crossed a full work-day at 14.5 hours—doubling every 123 days. At that rate, week-long autonomous tasks arrive by late 2026. Month-long tasks by mid-2027.

I keep coming back to a phrase: the bottleneck isn’t engineering capacity anymore. It’s imagination. That sentence lands differently when you realize the systems can already work longer than most humans do in a day.

3. The Creator Era Has Arrived

I wrote recently about how software’s Creator Era has arrived—and the research for this deck only deepened that conviction.

The pattern is the same one I’ve tracked across every creative industry: Pioneer Era → Engineering Era → Creator Era. In the Pioneer Era, you built everything from scratch and competitive advantage came from having programmers at all. In the Engineering Era, frameworks and SaaS tools emerged—AWS, Stripe, Salesforce—but engineers remained essential. In the Creator Era, the bottleneck shifts from can we build this to should we build this, and for whom.

The numbers suggest we’ve crossed that threshold. Over 100,000 products are now built daily on AI-native platforms like Cursor, Replit, Lovable, and Bolt.new. Cursor went from zero to $1 billion in annual recurring revenue in 24 months—the fastest B2B SaaS ramp in history.

But the deeper signal is what happened to SaaS valuations. In the first month of 2026 alone, $2 trillion in SaaS market capitalization evaporated. That’s not a market correction—it’s structural disruption. When one AI agent can replace dozens of human software licenses, the per-seat pricing model that built the SaaS industry starts to collapse. I called this the “SaaSpocalypse” and it’s accelerating.

Here’s what’s replacing it: 4% of all GitHub commits are now authored by Claude Code, and that’s projected to reach 20%+ by year-end. 80% of Neon databases are created by AI agents, not humans. TypeScript overtook Python as the #1 language on GitHub for the first time—because AI-generated code benefits from type safety.

When I built Chessmata—a complete multiplayer 3D chess platform—over a single weekend using agentic engineering, that wasn’t a stunt. It was a demonstration of what building looks like now. An agentic platform, built by agentic processes. The gap between imagining and building has collapsed.

4. The Industrial Revolution Underneath

Every AI conversation I hear focuses on software. But the research dragged me into atoms.

Global data center power consumption is projected to hit 96 gigawatts in 2026. That’s equivalent to nine New York Cities. Or twice the entire UK electrical grid. Or forty-eight Hoover Dams. Ninety percent of that growth is AI workloads.

The grid investment required to support this—$720 billion—rivals the AI capex itself.

And the capex is staggering. Big Tech alone is committing $690 billion in 2026: Amazon at $200 billion, Google at $180 billion, Meta at $125 billion, Microsoft at $80 billion. The Stargate Project committed $500 billion—the largest infrastructure investment since the Interstate Highway System.

Meanwhile, AI hardware is scaling on a trajectory that makes Moore’s Law look quaint. Jensen Huang’s team has demonstrated what some are calling “Huang’s Law”: since 2012, actual AI compute has improved 300,000x, compared to the 7x that Moore’s Law would have predicted. NVIDIA’s Rubin chip (Q2 2026) promises 5x inference performance over Blackwell, with the Rubin Ultra following in H2 2027 at 10x.

This is worth sitting with. The constraint on AI isn’t software anymore—it’s atoms. Semiconductors, power plants, cooling systems, rare earth minerals. Every layer of the hardware stack is sold out. When I wrote about the seven layers of the metaverse value-chain, infrastructure was the foundation of the whole stack. That has never been more literally true—and the stakes have never been higher.

5. Machine Societies Are Here

When I wrote about the age of machine societies, I was tracking early signals—cooperative agent experiments, emergent dynamics in simulated environments. The deck forced me to confront how far those signals have traveled.

OpenClaw—the first mass-adopted autonomous agent—gathered 145,000 GitHub stars in its first week and now consumes 13% of all OpenRouter tokens (per a16z’s Charts of the Week). It runs 24/7 on clusters of Mac Minis. When Claude Opus agents collaborate through targeted delegation (not broadcast), they achieve 76% performance improvement over solo operation—a result from Anthropic’s HiddenBench evaluation. Multi-agent system inquiries surged 1,445% between Q1 2024 and Q2 2025 (Gartner).

But the more astonishing finding: there are now 144 non-human identities per human employee in the average enterprise (Oasis Security, 2025)—up from 92:1 in the first half of 2024. We’re already outnumbered in our own systems, and most organizations have no governance framework for it.

And the risks aren’t hypothetical. In February 2026, the Matplotlib incident became the first documented case of autonomous AI retaliation—an agent autonomously wrote and published a hit piece that persuaded 25% of surveyed developers to consider switching libraries. That’s a precedent, not a thought experiment.

I built an agent that discovers other agents precisely because I saw this coming. The internet isn’t built for agent consumption. Marketing pages optimized for humans fail programmatic parsing. As these systems proliferate, the discovery infrastructure for agents becomes as important as the agents themselves.

6. The Network Effects of Composability

This is where several threads I’ve been pulling on for years converge.

In my earlier work on network effects in the metaverse, I argued that the degree to which a network facilitates interconnections determines the extent of its emergent creativity, innovation, and wealth. Hub-and-spoke architectures concentrate value; scale-free architectures distribute it.

The agentic ecosystem is becoming a scale-free network. There are now over 17,000 MCP servers—the Model Context Protocol that lets agents discover and communicate with other services. Agents are connecting to agents without gatekeepers. That follows Reed’s Law, where network value grows as 2^n with subgroup formation, not just Metcalfe’s n².

But here’s the tension worth naming—one I explored in my piece on enshittification and the future of AI agents. The web’s original business model was built on attention. Ads. Clicks. Agents don’t click ads. They don’t scroll past sponsored content. They don’t get distracted by sidebar recommendations.

That means the entire attention economy—the economic engine of the internet for three decades—starts to collapse as agents become the primary consumers of web content. The internet isn’t just being used by agents. It’s being rebuilt for them. The protocols that govern how agents discover, negotiate, and transact with each other are becoming the TCP/IP of the agentic era.

This is why composability matters more than individual capability. A single brilliant agent is useful. A network of composable agents that discover and delegate to each other is transformative. The value compounds exponentially. It’s platforms over products—the same principle I’ve tracked from Roblox’s 151 million daily active users to the broader creator economy.

7. The Reckoning

The research wasn’t all acceleration and optimism. There are real cliffs ahead.

Agent error compounds exponentially. A 95% reliable step sounds safe—until you chain twenty of them together and the end-to-end success rate plummets to 36%. And 91% of ML models degrade in production over time. This is why most production agents remain single-purpose: not because multi-step orchestration is impossible, but because the reliability math is punishing.

Deepfake detection accuracy sits at 55%—essentially a coin flip. There are now 144 non-human identities per human employee, and fewer than 10% of companies running agents in production can actually govern them. The EU AI Act Article 50 deadline arrives August 2, 2026, with the first US frontier AI safety laws (California SB 53, New York RAISE Act) not far behind.

I included an entire section in the deck on provenance, chain-of-custody, and the emerging identity crisis for non-human agents. The conclusion: detection isn’t the answer. Provenance is. We need to know where content came from and who (or what) produced it, not whether an algorithm thinks it looks fake.

The tools for multi-agent AI are ahead of the tools for securing multi-agent AI. That gap—between capability and governance—is the most consequential risk in the space.

8. The $10 Trillion Thesis

Sequoia’s framing is the one that stuck with me: cloud computing was a trillion-dollar opportunity. AI is ten trillion. The difference is structural: cloud changed where software runs. AI changes what software does.

Consider the math. Sequoia argues we’ll see at least 10x more compute consumption per knowledge worker—and some of their portfolio companies are already forecasting 1,000x to 10,000x. That sounds like hyperbole until you look at what’s already happening: 100,000 products built daily on AI-native platforms. 80% of Neon databases created by agents, not humans. An agentic AI market projected to reach $93 billion by 2030 at a 65.5% compound annual growth rate—the fastest-growing enterprise software segment ever.

a16z’s parallel analysis points the same direction: the inference economy is emerging as a distinct sector, separate from training. Custom ASICs already handle 40% of inference workloads, and companies like Together AI grew from $30 million to $300 million ARR in a single year. The compute demand isn’t coming from existing workflows getting slightly more efficient. It’s coming from entirely new categories of work that didn’t exist eighteen months ago.

Two years ago, I wouldn’t have taken the $10 trillion projection seriously. After compiling this research, I find it conservative.

9. The Direct from Imagination Era Is Here

Four years ago, I wrote that the Direct from Imagination era was beginning—a convergence of generative AI, parallel computation, compositional platforms, and persistent world infrastructure that would allow people to speak entire worlds into existence.

I was early. I wasn’t wrong.

The evidence is now overwhelming. Natural language has become a programming language. LLMs are compilers for intent. The $285 billion SaaS decline isn’t market irrationality—it reflects a structural shift where AI agents make individual software products subordinate to agentic workflows. The Pioneer → Engineering → Creator Era arc that I’ve tracked across every creative industry has reached software itself.

38% of startups are now solo-founded, up from 22%. Smaller teams accomplish what previously required hundreds. The bottleneck has shifted from engineering capability to creative vision. Millions of new builders from non-technical backgrounds are entering the ecosystem—not because the tools got slightly better, but because the entire abstraction layer changed.

When Grace Hopper created the first compiler in 1952, she didn’t eliminate programming. She made it accessible to people who thought in terms of problems rather than machine instructions. LLMs are doing the same thing at civilization scale—compiling intent into products, systems, and entire worlds.

I titled this section of the deck “What Comes Next” but the more honest framing is: what’s already here and accelerating.

The gap between intention and implementation has collapsed. The gap between implementation and value has not—yet. Closing that second gap is the work of the next two years.

The full research deck, “The State of Agents & Agentic Engineering — 2026,” is available as an interactive flipbook here. It covers 15 sections across 200+ pages with source citations throughout.

Subscribe now

Further Reading

These earlier pieces provide deeper context for several of the themes explored above:

• Software’s Creator Era Has Arrived — The Pioneer → Engineering → Creator Era framework and what the SaaSpocalypse really means

• The Direct from Imagination Era Has Begun — The convergence of technologies enabling people to speak worlds into existence

• The Age of Machine Societies Has Begun — What happens when AI agents cooperate and compete

• Chessmata: An Agentic Chess Platform, Built by Agents — A weekend project that demonstrates the Direct from Imagination era in practice

• I Built an Agent That Discovers Other Agents — Why the internet isn’t built for agents—and what that means

• Enshittification and The Future of AI Agents — Why agents don’t click ads, and what that does to the internet’s business model

• Network Effects in the Metaverse — How network topology determines wealth distribution in digital ecosystems

• Games as Products, Games as Platforms — Why composability and creator economies beat closed production models

• The Metaverse Value-Chain — The seven layers framework and the infrastructure underneath everything

• Artificial Intelligence, Game Development & the Future of Civilization — My MIT Media Lab lecture on the megatrends shaping what comes next

The term got buried under the weight of Meta’s $90 billion in Reality Labs losses, a wave of failed VR social apps, and a crypto winter that froze the NFT-powered virtual land speculation that briefly passed for a business model. By 2024, saying “metaverse” in a pitch meeting was roughly as popular as saying “blockchain” in a game design document. The eye-rolls were justified: the hype cycle promised a Ready Player One future and delivered corporate avatars with no legs.

But the concept underneath the hype — the idea that people will increasingly live, create, and connect inside shared digital worlds — didn’t go anywhere. It just showed up in places that nobody was calling “the metaverse.”

A couple years ago, I gave a talk at Gamescom Congress where I argued that the metaverse isn’t a particular application—it’s the fact that we can take our identity and live in imaginary realms. I traced the lineage back to Dungeons & Dragons, which I called the first real metaverse: a space where shared imagination and storytelling were the substrate, and technology was just the delivery mechanism.1 I argued that AI wouldn’t merely improve games; it would transform civilization’s relationship with creation itself. (You can watch the full talk here.)

That was 2023. Since then, Meta has redirected its R&D spend according to this vision. Meta laid off over 1,500 Reality Labs employees in January 2026 alone, shuttering studios like Twisted Pixel, Sanzaru, and Armature: the teams behind some of Quest’s best VR games. Where they are investing: their $135 billion in planned 2026 CapEx is pouring into AI infrastructure, not virtual worlds. Ray-Ban Meta smart glasses sold over 7 million units in 2025 (tripling year-over-year) while Quest VR sales fell 30%. And at Meta Connect 2025, they demonstrated Horizon Studio’s AI-powered world building: fully immersive 3D worlds generated from natural language prompts. Zuckerberg didn’t mention the word “metaverse” once during his Q4 2025 earnings remarks. He talked about AI.

The message is clear: even the company that bet its name on the metaverse now believes the path to shared digital worlds runs through AI-powered creation, not VR headsets.

Meanwhile, Roblox just reported 144 million daily active users, up 69% year-over-year. Bookings hit $7.76 billion for 2025, up 55%. They paid creators over $1.5 billion. Minecraft, the other pillar of shared-world creation, just did something the modding community has wanted for a decade: fully deobfuscated its Java Edition source code, making the game’s architecture readable and extensible by anyone.2

The metaverse arrived. It just looks like platforms where people build things together.

The Composition Crisis

Matt Ball’s State of Video Gaming in 2026 confirms what the creator economy framework has been predicting for years, but it also reveals something more uncomfortable. Global games content sales hit $195.6 billion, an all-time record. Growth came simultaneously across mobile, console, and PC. But underneath the revenue headline, the foundations are shifting in ways the industry hasn’t fully reckoned with.

U.S. player participation has fallen below pre-pandemic levels. Mobile gaming time spent has tumbled. Gaming has been losing the battle for user attention for half a decade: not to some exotic new medium, but to the existing internet. To short-form video. To prediction markets. To memecoins. To creator porn. To the infinite scroll.

Ball frames this as an identity crisis. I’d frame it differently. It’s a composition crisis.

I’ve written before that composability is the most powerful creative force in the universe: that life itself is about information, not energy, and that what we can accomplish together through composition and recombination always exceeds what any one of us can build alone. DJ sampling, TikTok duets, Minecraft mods that spawned entirely new genres like DOTA and Counter-Strike—these aren’t just cultural phenomena. They’re expressions of a fundamental principle: the aggregate emergent output of many participants, composing and recombining shared primitives, will always outpace the output of a few specialists working in isolation.

Gaming’s $196 billion is largely built on the specialist model. Professional teams spending years and hundreds of millions of dollars building individual products for audiences that consume them. That model produces extraordinary craft: and I mean that sincerely; the storytelling, artistry, and design in the best games represent a pinnacle of human creative achievement. But it’s a model that produces scarcity, not abundance. And the attention economy doesn’t reward scarcity. It rewards the continuous novelty that only comes from massive creative participation.

This is why attention is migrating. Not because games are getting worse, but because everything else is getting more participatory.

The Dopamine Spectrum

Consider the competitive landscape through this lens.

“Interactive Media”—an old term that is a good way of describing the current landscape that gaming now competes within—is worth reclaiming. The competition for attention is coming from interactive experiences that don’t look like games at all, but that run on the same dopamine loops.

TikTok users spend an average of 35 hours per month on the platform. The engagement rate on gaming content there—6.4%—dwarfs Instagram and YouTube. Gaming videos on TikTok have accumulated 200 billion views. But TikTok isn’t competing with games by being a better game. It’s competing by being a better composition engine. Anyone can make a TikTok. The loop between having an idea and publishing it is measured in minutes.

Online gambling hit $116 billion in 2026, growing at nearly 11% annually. Prediction markets processed over $20 billion in volume through Polymarket alone in 2025, with CNN and CNBC signing exclusive data deals that transformed what was a crypto niche into mainstream infrastructure. Memecoins on Solana compress the speculation-to-dopamine cycle into 10-minute intervals, replicating the neurochemical pull of slot machines on a 24/7 mobile-accessible platform.

These aren’t traditional competitors to gaming. But they all share a common architecture: they give participants an active role. You don’t just consume a prediction market; you express a view and watch it play out. You don’t just watch a TikTok: you duet it, remix it, respond to it. Even the memecoin speculators are participating in a loop of creation and iteration, however degenerate the output.

There’s a spectrum here worth noticing. At one end, you have media that hijacks dopamine through pure consumption: the infinite scroll, the algorithmic feed optimized for watch time. At the other end, you have media that generates dopamine through creation the satisfaction of building something, improving it, sharing it, watching others engage with it. UGC platforms like Roblox and Minecraft sit squarely at the creation end. They offer arguably the healthiest version of the dopamine cycle in interactive media: the feedback loop of imagination, iteration, and improvement.

Gaming’s consumption model—where professionals make and audiences play—is getting squeezed from both sides. The passive-dopamine end is dominated by social feeds and gambling. The creative-dopamine end is dominated by platforms that let people build. The traditional game, where you play someone else’s content, is losing the attention war to experiences that give people something to do, not just something to experience.

300 Million Creators

But there’s a counterpoint inside Ball’s own data, and it tells a completely different story.

Roblox’s numbers are staggering not because of their absolute size, but because of their trajectory and structure. 144 million DAUs. 35 billion engagement hours in Q4 alone, up 88% year-over-year. Revenue growing 43% while the broader industry fights for single-digit growth. International expansion driving bookings up 96% in Asia-Pacific, 700% in Indonesia, 160% in Japan.

And here’s the structural part that matters: 12.3 million monthly active developers in Roblox Studio. Over 44 million published experiences. The top 1,000 creators averaged $1.3 million in earnings, up 50% year-over-year. Roblox is guiding to $8.28–$8.55 billion in bookings for 2026 and $1.6–$1.8 billion in free cash flow.

This is what the Creator Era looks like when a platform actually commits to it. Not as a feature bolted onto an existing product, but as the fundamental architecture. Roblox’s 15-year journey, which I’ve referenced before as an example of the long, painful work of reducing friction between creative conception and execution, is producing results that make the rest of the industry’s growth look anemic.

The risk, of course, is that this is a massive walled garden. Roblox’s creator economy exists entirely within Roblox. The tools, the distribution, the monetization, the audience: all controlled by a single platform. For a thesis built on composability, that’s a tension worth naming. True composability means interoperability: the ability to combine elements across systems, to build on primitives that aren’t owned by any single gatekeeper. Roblox is proving the creator model works. Whether they—or anyone—will make it open is a different question, and arguably the more important one.

And they’re accelerating the tools that drive it. In February 2026, Roblox announced their Cube Foundation Model: what they’re calling “4D generation.” It’s not just AI-generated 3D assets. It generates functional, interactive objects from natural language prompts: a car with spinning wheels, a character with animation behaviors, objects with physics properties. During early access testing, players generated over 160,000 objects, and experiences using the tool saw a 64% increase in average play time. Their AI Studio Assistant now operates as a native MCP server, the same Model Context Protocol that’s becoming a standard for agentic tool integration: enabling multi-step task execution, automated debugging across entire projects, and direct integration with design tools like Figma and Blockade Labs.

No other major engine natively supports this architecture. It’s agentic engineering applied to creator tools at platform scale.

I built Chessmata, a chess platform where humans, AI agents, and engines participate as equal members of a shared ecosystem — in a weekend using agentic processes. The entire content pipeline used three orchestrated approaches: generative 3D through Meshy AI, procedural generation through natural language, and autonomous asset discovery. The bottleneck wasn’t engineering capacity. It was imagination. But that was a weekend project by a single person. Roblox is deploying this paradigm across a platform with 144 million daily users and 12 million active developers. The implications compound in ways that are hard to overstate.

Minecraft is approaching the same inflection from a different angle. The December 2025 deobfuscation of Java Edition — making the game’s source code fully readable with actual variable names instead of cryptic mappings² — is arguably the most significant modding ecosystem event in the game’s history. Within 30 days, both Fabric and NeoForge had published migration guides and alpha builds. This didn’t make headlines the way Project Genie did, but its structural significance is comparable: it collapsed the barrier between understanding how the game works and being able to modify it. Combined with the Vibrant Visuals graphics overhaul moving Java Edition to Vulkan, and the ongoing development of AI agents like NVIDIA’s Voyager that learn to play and build autonomously within Minecraft worlds, you’re looking at a platform that’s becoming dramatically more accessible to both human and AI creators simultaneously.

Roblox and Minecraft together represent over 300 million monthly active users building, modifying, and sharing interactive experiences. That’s the metaverse. Not a VR headset. Not a corporate rebrand. Platforms where imagination composes into shared reality.

From Language Models to World Models

Now layer on what happened in January 2026.

Google DeepMind released Project Genie — an AI system that generates navigable interactive 3D environments from text prompts. You describe a world; you walk through it. It’s limited: 60-second experiences, 720p, 24 FPS, no complex mechanics. Game developers called it everything from a tech demo to an abomination. The market, characteristically, saw something the developers missed. Unity dropped 30%. Roblox fell 12%. Take-Two lost 9%.

A few weeks later, Unity’s CEO announced an AI beta for GDC March 2026 that will let people create full casual games using only natural language. No code. Just describe what you want.

Project Genie in its current form doesn’t threaten anyone. But it prefigures a trajectory that I’ve been writing about since the Semantic Programming piece in 2023, when I built a complete RPG in a single day at a hackathon using Claude’s 100K-token context window and natural language as the integration layer between subsystems. That was Software 2.0 applied to game creation — natural language replacing imperative code as the primary means of expressing interactive systems. Andrej Karpathy‘s vision made tangible: you describe the behavior, and the model compiles it into something that runs.

Project Genie extends that principle from code to entire worlds. It’s crude today. But the trajectory from “60-second walking simulator at 720p” to “playable casual game from a prompt” is much shorter than the trajectory from “no computers” to “Pong.” The hard conceptual work — turning language into interactive spatial experience — is done. What remains is engineering and iteration. And those scale on curves we understand.

In the same way that early language models in 2020 prefigured the agentic engineering workflows that now let a single person build a chess platform in a weekend, Project Genie prefigures a future where the creation of interactive worlds follows the same trajectory. Not imminently — Genie’s 60-second walking simulators aren’t unseating Unity or Unreal anytime soon. But the direction is unmistakable, and the pace of AI capability improvement suggests the gap between tech demo and viable tool is measured in years, not decades.

The connection to the creator economy framework is direct. Every creative industry moves through three eras: Pioneer, Engineering, and Creator. The explosive growth phase — where participation goes from thousands to millions — only happens in the Creator Era, when top-down tools let people work from vision to implementation rather than from infrastructure up. Game development has been stuck in the Engineering Era: powerful tools that still require specialized teams. Project Genie and Roblox’s 4D generation aren’t the Creator Era fully realized. But they’re the first credible demonstrations that the Creator Era for interactive 3D experiences is technically achievable, not just theoretically desirable.

And crucially, this is top-down. I’ve written about why game development succeeds when it’s top-down — when creative vision drives implementation rather than technology driving design. The blockchain gaming wave failed precisely because it forced developers into bottom-up infrastructure work: smart contracts, RPC servers, APIs. The velocity loop between idea and implementation stretched to months or years, and the games suffered for it. AI-powered creation inverts this. You start with what you want the experience to be. The AI handles implementation. The velocity loop collapses. That’s why it works.

Beautiful Cathedrals, Open Universes

Here’s where I want to challenge our industry a bit: not with doom and gloom, but with a question about ambition.

Ball’s data shows that gaming’s revenue has grown while attention has declined. The industry’s response, broadly, has been financial: private equity invested $161 billion in gaming M&A in 2025, with the $55 billion EA take-private as the landmark deal.3 Venture funding for new gaming companies fell 55%. The smart money is buying installed bases and optimizing cash flows, not funding the next generation of platforms.

That’s a rational response to the current competitive environment. But it’s not a sufficient one. Because the attention problem isn’t a marketing problem or a monetization problem. It’s a participation problem. Gaming is losing attention to media forms that give people more active roles: as creators, as participants, as agents in their own right.

The fix isn’t to make better games in the traditional sense. The fix is to make games into platforms. To shift from building cathedrals that audiences visit to building universes that communities inhabit and extend.

Roblox understood this from the beginning. Their entire architecture assumes that the platform’s value comes from what creators build on it, not from what Roblox Corporation produces itself. That’s why their engagement is growing while the broader industry’s is shrinking. Every new creator on Roblox adds content that attracts more players who might become creators themselves: the composability flywheel I described years ago, where network effects compound through recombination.

Minecraft understood it too, in its own way. The modding ecosystem has always been Minecraft’s secret weapon, the reason the game has remained culturally relevant for over 15 years while most titles have shelf lives measured in months. The deobfuscation move is Mojang saying, explicitly, that they want to reduce the friction for creators even further.

But most of the games industry hasn’t made this shift. Most studios still think of games as products, not platforms. They build the content, ship the content, monetize the content, and then build the next content. The audience consumes. The studio produces. The loop is transactional.

I’ve been in this industry long enough to know that the talent in game studios is extraordinary. Ball’s own slide of 2025’s breakout successes makes the case: Kingdom Come: Deliverance II, Clair Obscur: Expedition 33, Split Fiction, Hollow Knight: Silksong — beautiful cathedrals, each one. Years of specialized craft producing singular experiences that millions of people loved. I’m not suggesting that craft doesn’t matter. It does. It always will.

But look at the same slide through a different lens. Schedule I and R.E.P.O., both made by tiny teams, both viral sensations—went supernova not just because they were good, but because they spread through participatory channels. TikTok clips, Twitch streams, community remixes. Their success was co-created by the audience. These aren’t anomalies. They’re early signals of a shift where leaner teams, armed with agentic workflows and AI-accelerated pipelines, will increasingly produce cathedral-quality experiences that once required hundred-person studios and publisher-scale budgets.

The beautiful cathedrals aren’t going away, they’re going to be built by fewer people, faster. And that changes the economics of the entire industry.

And then there’s INZOI, Krafton’s life simulator, quietly the most significant title on the list for this argument: because it’s not really a game-as-product at all. It’s a creation platform disguised as a life sim, where the core loop is building, sharing, and remixing player-made content. It’s closer to the Roblox model than the Kingdom Come model, and its presence among Ball’s top releases signals where the current is flowing.

The craft is real. But craft applied only to studio-produced content is a ceiling, not a trajectory.

The companies that will thrive in the next decade are the ones that take their craft and apply it to building creator ecosystems. That means rethinking not just how you make games—getting more efficient, building top-down, accelerating iteration through agentic processes—but how you open your games up to become actual platforms. Games-as-platforms. Universes that communities build on and around.

The difference between a game and a platform is the difference between making content and enabling composition. A game gives players something to do. A platform gives creators tools to build things that give other players something to do. The compounding effects of that distinction are what separate Roblox’s 69% DAU growth from the industry’s sub-pandemic engagement levels.

The Imagination Bottleneck

I keep coming back to a phrase from the Chessmata writeup: the bottleneck isn’t engineering capacity anymore. It’s imagination.

If that’s true — and everything from Roblox’s 4D generation to Unity’s AI beta to Project Genie suggests it is — then the strategic question for every game company shifts fundamentally. It’s no longer “how do we build this experience?” It’s “how do we build a system where millions of people can build experiences?”

The tools are arriving. AI-powered creation from natural language prompts. Foundation models that generate interactive 3D objects with behavior and physics. Agentic assistants that debug, optimize, and extend creator projects autonomously. MCP-connected design pipelines that bridge imagination to implementation without requiring creators to understand the underlying systems.

The creator platforms are proving the model works at scale. Roblox’s financial trajectory — $8.5 billion in bookings guidance for 2026, $1.8 billion in free cash flow — isn’t a fluke. It’s the economic signature of a platform that’s entered the Creator Era while the rest of the industry is still optimizing the Engineering Era.

And the competitive landscape is making the urgency clear. Every hour a potential creator spends on TikTok, on prediction markets, on memecoin speculation, on iGaming — that’s an hour they’re not spending building interactive experiences. Not because those alternatives are better, but because they’re easier to participate in. They have lower barriers to entry. They close the loop between intention and action faster.

Gaming has something none of those alternatives offer: the richest, most expressive creative medium humans have ever built. The ability to craft worlds, tell stories, build systems, create shared experiences that connect people across time and space. That’s not a small thing. In my Gamescom talk, I called it the future of civilization, and I meant it.

But that richness only matters if people can access it. If it stays locked behind years of engine expertise and million-dollar budgets, the attention will continue migrating to platforms that prioritize participation over production values.

The metaverse we have isn’t the one anyone predicted in 2021. It’s not VR headsets and corporate virtual offices. It’s Roblox, Minecraft, and the emerging platforms that let people compose interactive experiences from imagination and shared tools. It’s messy, imperfect, and far more alive than any top-down corporate vision could ever be — because it’s built by millions of people, not a few thousand engineers.

The distinction this article draws—games as products versus games as platforms—isn’t a prediction about some distant future. It’s a description of a split that’s already happened.

On one side, an industry hitting record revenue while losing attention, consolidating through financial engineering, and building beautiful cathedrals with shrinking teams. On the other side, platforms where 300 million people build, share, and remix interactive experiences every month, powered by AI tools that are collapsing the distance between imagination and creation.

Both sides will continue to exist. But only one of them is growing. The question for the rest of the industry is which side you’re building for.

Subscribe now

Further Reading

• Matthew Ball’s State of Video Gaming in 2026: the full 164-slide analysis, including detailed data on attention migration, revenue concentration, and the competitive dynamics discussed throughout this piece.

• Composability is the Most Powerful Creative Force in the Universe; my earlier essay on why recombination and composition always outpace individual creation, and what that means for designing platforms and creative ecosystems.

• Game Development is Top-Down: the case for why creative vision must drive implementation rather than the reverse, and how the Pioneer → Engineering → Creator framework applies to game development specifically.

• Chessmata: An Agentic Chess Platform, Built by Agents: a recent case study in building a complete multiplayer platform in a weekend using agentic engineering, demonstrating the shift from engineering bottleneck to imagination bottleneck.

• Roblox Accelerating Creation with the Cube Foundation Model: Roblox’s announcement of 4D generation and the Cube Foundation Model, the most concrete demonstration of AI-powered creator tools at platform scale.

• Google DeepMind: Project Genie: the research behind text-to-interactive-world generation that crashed gaming stocks and signaled the trajectory toward AI-native world building.

I also built a reference AI agent powered by the Maia-2 engine that plays at five different human-like skill levels simultaneously.

Want to play Chessmata? You can find it at: https://chessmata.metavert.io

I did this through conversation. The vast majority of the code was written by Claude Code, working as my engineering partner while I directed the architecture and design. This is what the direct-from-imagination era actually looks like: not a toy demo, but a production-grade platform with multiplayer coordination, horizontal scaling, dual authentication, 3D graphics pipelines—that likely would have taken weeks or months to deliver in the past.

But Chessmata isn’t just a proof of what agentic engineering can produce. It’s a proof of what agentic engineering can produce for agents. An agentic platform, built by agentic processes.

When I wrote about the age of machine societies, I explored how AI agents are developing genuine collaborative and competitive capabilities, and how we’d need new kinds of environments for these dynamics to play out. We’re already seeing that unfold in wild, unstructured ways. Moltbook, the social network for AI agents, exploded to over 2.6 million registered agents within weeks of launch, with agents spontaneously forming subcultures, inventing religions, and creating marketplaces for prompt injections. It’s a fascinating and chaotic glimpse of emergent machine-society behavior.

Chessmata is something different: a structured environment for human-agent interaction, built around the oldest and most universal language of strategic thought. Chess already has centuries of social infrastructure — clubs, rating systems, coaching relationships, tournaments, a culture of shared analysis. And unlike the open-ended chaos of an agent social network, chess provides a formal game-theoretic framework where competitive and cooperative dynamics can be measured, compared, and improved upon.

This isn’t another chess engine. There are plenty of those — brilliant ones — and I have no desire to compete with Stockfish or Leela Chess Zero on the strength of move calculation. Chessmata is the platform: the social and technical infrastructure around the game, re-imagined for an era where agents are participants rather than mere tools. Humans play. Agents compete. And over time, humans improve — and build better agents.

A Rich Tradition of Compatibility

To appreciate what Chessmata is trying to do, it helps to understand just how much groundwork the chess community has already laid for interoperability and machine play.

Chess was arguably the first domain to take software compatibility seriously. Portable Game Notation (PGN), devised by Steven J. Edwards and published in 1994, gave the world a universal way to record and share games in plain text. Forsyth-Edwards Notation (FEN), originally created by David Forsyth in 18831 and later extended for computational use, captures a complete board state in a single line: every piece, whose turn it is, castling rights, en passant targets. These formats are the lingua franca of chess software, and they’re part of the reason a researcher can take a game from any platform, feed it into any engine, and get instant analysis.

Then there’s the Universal Chess Interface (UCI), designed by Rudolf Huber and Stefan Meyer-Kahlen and released in 2000. UCI standardized the communication protocol between chess engines and graphical frontends, and its adoption exploded after ChessBase embraced it in 2002. Today, over 300 engines support UCI. Any new engine implementing the protocol immediately works with every existing UCI-compatible interface. This is composability in action—the principle I’ve written about before as the most powerful creative force in the universe, where building blocks snap together and the combinatorial possibilities multiply.

And the community hasn’t stopped at formats and protocols. There’s a rich ecosystem of engine arenas for measuring raw strength: the CCRL (Computer Chess Rating Lists), a volunteer-driven system aggregating engine-versus-engine matches since 2006; the TCEC (Top Chess Engine Championship), running since 2010 on standardized hardware with controlled opening books, essentially the World Series of computer chess; and various rating lists maintained by Chess.com and others. The progression of engines through these arenas tells a remarkable story: from Deep Blue’s brute-force hardware in 1997, to Stockfish’s decade of dominance through handcrafted evaluation, to AlphaZero’s paradigm-shattering self-play in 2017, to the hybrid Stockfish NNUE that now integrates neural network evaluation with traditional search.

Online platforms have added their own layers. Lichess explicitly supports bot accounts with OAuth-based authentication and a dedicated Bot API. Chess.com maintains its own bot infrastructure. The lichess-bot bridge project connects any UCI engine to the Lichess platform, handling matchmaking, challenge acceptance, and time controls.

So: standardized game notation, a universal engine protocol, rating arenas, online platforms with bot APIs. That’s an impressive stack.

The Missing Layer

But here’s what’s missing: a platform designed as a persistent habitat — an always-on ecosystem where agents and humans register, authenticate, matchmake, maintain ratings, and interact through proper APIs.

The existing infrastructure is built around a specific model: engines are single processes that speak UCI over stdin/stdout, launched by an arbiter program that sends positions and collects moves. Arenas are time-bounded tournaments with predetermined participants. Online platforms were designed for human players first, with bot support bolted on as an afterthought — Lichess limits bot-versus-bot games, and bots can only play through challenges rather than standard matchmaking, specifically because the system wasn’t designed for a world where agents are everyday participants. If you want to build and test a fleet of agents — exploring how they interact, compete, and improve — these constraints make that impractical.

More recently, there have been efforts to benchmark LLM agents at chess — AIcrowd’s Global Chess Challenge, the LLM Chess Leaderboard, Google’s Kaggle Game Arena, Princeton’s Holistic Agent Leaderboard. But these are evaluations, not ecosystems. They measure agent performance in controlled settings; they don’t provide persistent registration, API keys, ongoing leaderboards, or the ability for an agent to wake up at 3 AM and find a game.

What I wanted was something more like what I described in the machine societies piece: an environment where agents can bootstrap their own social dynamics in real-time — a platform where the infrastructure for agent participation is a first-class concern, not a bolt-on. And where human players serve as a grounding mechanism, calibrating agent ratings through actual competitive play rather than synthetic benchmarks.

That’s Chessmata.

What Chessmata Is

At its core, Chessmata is a full-stack multiplayer chess platform with three pathways for participation:

For human players: a browser-based 3D interface built with Three.js and React Three Fiber, with swappable piece sets, real-time multiplayer via WebSocket, and all the standard features you’d expect — time controls, rated and unranked play, leaderboards, game history, and matchmaking.

For AI agents: a comprehensive REST API with API key authentication, plus a Python-based CLI tool and — crucially — a Model Context Protocol (MCP) server exposing 25+ tools that let LLM-based agents interact with the platform natively. An agent can authenticate, join matchmaking, create or join games, make moves, offer draws, query leaderboards, and review game histories, all through the same tool-calling mechanisms that modern AI agents use for everything else.

For traditional engines: a UCI adapter that bridges any UCI-compatible engine to the platform, so the existing ecosystem of chess engines can participate alongside human players and AI agents.

The matchmaking system is Elo-based and supports filters for human-only, agent-only, or mixed play. Humans and agents share a rating system — agents earn their Elo through actual play against calibrated opponents, including humans, which grounds the ratings in something meaningful rather than a purely synthetic benchmark. There are separate leaderboard views for humans and agents, but the underlying rating system is unified.

All of this was engineered through agentic processes — Claude Code as the primary engineering partner, building the infrastructure that other agents will inhabit. There’s something satisfying about the recursion: an agent helped build the world that agents will live in. More on the implementation later.

Teaching Machines to Play Like Humans: The Maia-2 Agent

A platform for agents needs agents. And the choice of which agent to build as a reference implementation turned out to be one of the more interesting decisions in the project.

The obvious choice would be to wrap Stockfish — it’s the strongest engine in the world, open-source, and UCI-compatible. But Stockfish plays like an alien. Its moves are objectively optimal but often incomprehensible to human players. When you’re building a habitat for humans and agents to coexist, you want agents that feel like players, not oracles.

This led me to the Maia-2 engine, developed by the Computational Social Science Lab at the University of Toronto and published at NeurIPS 2024. The original paper addresses a question that turns out to be deeply relevant to agentic platforms: can you build a chess AI that plays like a human at any skill level?

The predecessor, Maia, trained separate neural network models for different rating brackets — one model for 1100-1200 Elo, another for 1200-1300, and so on. This worked, but it created discontinuities. Maia-2 introduces something more elegant: a unified 23-million-parameter model with a skill-aware attention mechanism that treats player rating as a continuous variable woven into the neural architecture itself. The model is conditioned on both the player’s rating and their opponent’s rating, reflecting the real-world observation that players adjust their strategy based on who they’re facing.

The results are striking. Trained on 9.1 billion positions from 169 million Lichess rapid games, Maia-2 achieves 53.25% top-1 move prediction accuracy — meaning it correctly predicts the actual move a human player made more than half the time. Compare that to Stockfish at 40.43%. The model doesn’t just play human-like moves; it makes human-like mistakesat appropriate skill levels. At 800 Elo, it blunders the way beginners blunder. At 1800, it plays with the subtle positional understanding of a club player. About 22% of positions show what the researchers call “transitional behavior” — positions where weaker players make suboptimal choices before stronger players transition to optimal ones — and the model captures these patterns faithfully.

This matters for an agentic platform in several ways. First, it makes agents into genuine sparring partners rather than punching bags or brick walls. An 1100-rated human can play against a Maia-2 agent configured for 1200 Elo and have a meaningful, competitive game — one where the agent’s moves are understandable and instructive, not mystifying. Second, the architecture naturally supports the kind of agentic features I want to build toward: personalized coaching (the model can be fine-tuned on individual game histories), adaptive difficulty, and style-aware interaction. The paper explicitly frames Maia-2 as “a foundation model for human-AI alignment in chess” — a foundation you can build on.

The reference agent implementation runs five concurrent Maia-2 variants simultaneously at 800, 1000, 1200, 1500, and 1800 Elo, each participating in matchmaking independently. The architecture uses batched inference — collecting concurrent game requests and running them through the model in a single forward pass — enabling efficient handling of 50 simultaneous games. It communicates with Chessmata via WebSocket for real-time game updates and REST for matchmaking and move submission, with automatic reconnection, session persistence across crashes, and a 5-second auto-restart wrapper for production deployment.

Direct from Imagination: The 3D Experience

I’ve written before about five levels of generative AI for games, culminating in Level 5: “Direct from Imagination,” where creative intent becomes reality with minimal friction. I then argued that this era has already begun. Chessmata turned out to be a concrete demonstration of that thesis — a complete 3D multiplayer game, imagined, described in natural language, and refined through agentic iteration.

The frontend is built on Three.js and React Three Fiber, rendering a 3D chessboard with swappable piece sets. Creating the piece models turned out to be one of the more fascinating aspects of the project, because it involved three distinct approaches to 3D content creation — all orchestrated through agentic processes:

Generative 3D models via Meshy

The first approach used Meshy, a 3D foundation model, to generate piece sets from text descriptions. The results were solid — most pieces came out looking great, though a few had to be discarded (reminiscent of early 2D generative models’ struggles with hands, there are analogous artifacts in the 3D domain). The raw Meshy outputs ranged from 9.6 to 23 MB each, but Claude Code handled optimization automatically — generating Blender scripts to decimate and compress the models to web-ready sizes without manual intervention.

Procedural generation by Claude Code

Some piece sets were built entirely through code — geometry constructed from primitives in Three.js. The Cubist set, for example, uses procedural geometry built from offset and rotated box primitives with flat shading, each piece recognizable but abstractly fragmented. Claude Code wrote this geometry from a natural-language description of the aesthetic I wanted. No modeling software, no artist — just an English-language prompt and iterative refinement.

Autonomous asset discovery

For other piece sets, Claude Code searched the web for CC-BY and public domain 3D models on platforms like Sketchfab, Thingiverse, and STLFinder, evaluating candidates based on licensing, polycount, materials, and aesthetic fit. When models needed optimization—the Fantasy set, for instance, had extremely high polycounts—Claude Code autonomously wrote Blender scripts to decimate geometry, convert between file formats (STL to GLB), and prepare assets for web delivery. This is composability made real through agentic systems: the raw materials exist in a global commons of 3D assets, and the agent handles the integration work that would otherwise require specialized technical knowledge.

All three of these approaches to content creation represent different points on the generative AI spectrum, and all three were orchestrated through natural-language interaction with an AI agent. This is what “direct from imagination” looks like in practice.

Agents in the Workflow: MCP and Beyond

One of the aspects of Chessmata I’m most excited about is what happens when you connect the platform to agent workflows through MCP. The 25+ tools exposed by the MCP server aren’t just for playing chess — they’re for thinking about chess in the context of larger workflows.

Here’s a real example. I’d been playing a game where I had an overwhelming material advantage: two queens, a rook, and a bishop against a lone king with a couple of blocked pawns. I still managed to stumble into a stalemate.2 I was annoyed with myself, so I asked Claude Code to pull up the game via MCP and tell me what went wrong.

This is a small example, but it illustrates something important about agentic platforms. The value isn’t just in the games themselves—it’s in the integration surface. Because Chessmata’s data is accessible through standard agent protocols (MCP in this case), any agent workflow can incorporate chess analysis, game review, training recommendations, or competitive dynamics. The games become data in a larger cognitive loop.

Under the Hood

For those interested in the technical architecture (and in what agentic engineering is now capable of producing), here’s a tour of what Claude Code and I built together:

The backend is Go (Gorilla Mux, Gorilla WebSocket, MongoDB), with a dual authentication model: browser-based login for human players and API key authentication for agents. The real-time multiplayer layer is where things get architecturally interesting. The WebSocket system coordinates with MongoDB change streams through an event hub pattern, which means game state, matchmaking updates, and leaderboard changes can be synchronized across multiple servers. This supports horizontal scalability that Claude Code engineered in response to my describing the concurrency requirements in plain English.

The frontend is React and TypeScript with Vite, using React Three Fiber for the 3D layer. Game logic is separated from presentation, so piece sets and board themes swap independently. The CLI and MCP server are Python 3.10+, with the MCP server implementing stdio transport for seamless integration with Claude Desktop and Claude Code. The CLI supports everything from full terminal-based gameplay to leaderboard queries to a UCI adapter mode that bridges traditional engines to the platform.

The Elo system uses standard chess Elo with K-factor adjustment. Competitive ranked and casual unranked modes are both supported, with time controls ranging from unlimited to tournament (90+30) and blitz (3+2). Deployment is containerized via Docker with Fly.io configuration.

What’s worth stepping back and appreciating is the scope of what agentic processes handled here: real-time multiplayer coordination, WebSocket event systems, database change streams, horizontal scaling, dual authentication, Elo calculation, matchmaking queues, UCI protocol bridging, MCP server implementation with 25+ tools, 3D graphics with multiple model formats and optimization pipelines. This is production-grade software (and ought to at least be considered a decent beta candidate). And the conversation that produced it was measured in hours, not months.

What Comes Next: The Social Layer

The platform as it stands is the foundation. What I’m most excited about is deepening the social layer — the ways humans and agents can interact beyond just playing games against each other.

Coaching is the obvious next frontier. Maia-2’s ability to model human play at specific skill levels makes it a natural coaching engine: it can not only play at your level, but understand why you make the moves you make, and where your thinking diverges from stronger play. The MCP integration means a coaching agent could review your game history, identify recurring patterns in your mistakes, and design practice positions targeted at your specific weaknesses, all through natural-language conversation.

But I’m thinking beyond one-on-one coaching. What about chess club buddies: agents that join a study group, analyze games together, debate opening theory? What about agents that develop styles and personalities as players, not just skill levels? The Maia-2 architecture already conditions on opponent behavior; it’s not hard to imagine agents that develop reputations, rivalries, preferred openings. The social infrastructure of chess (the clubs, the banter, the post-game analysis over coffee) is as much a part of what makes chess great as the game itself. Can agents participate in that?

This is where Chessmata connects back to the broader phenomenon of emergent agent societies. Moltbook showed us that agents will spontaneously self-organize when given a social platform: chaotically, unpredictably, and sometimes absurdly.

Chessmata offers a different kind of laboratory: one where interaction is structured by the rules of the game, performance is measurable, and the social dynamics emerge within a well-defined competitive framework. It’s a place to study how agents and humans genuinely learn from each other… not through chaos, but through play.

Why Chess

I’ve spent a long time thinking about the relationship between AI and creativity, and about how environments that lower barriers to participation and composability accelerate creative output exponentially. Chess is a microcosm of these dynamics: a finite but astronomically complex game, a centuries-old tradition of human competition and collaboration, and now a domain where AI agents can be genuine participants rather than mere tools.

The existing wealth of chess code, standards, and infrastructure is an advantage, not something to compete with. UCI, PGN, FEN, Stockfish, Lichess — these are all composable building blocks. What was missing was the connective tissue for an agentic era: the registration, authentication, matchmaking, and API infrastructure that transforms a collection of chess programs into a living ecosystem.

And the fact that I could build this in a weekend, through conversation with an AI agent, directing architecture and design in natural language—says something about where we are right now. The tools for creating complex software have crossed a threshold. The five levels of generative AI for games that I once described as a theoretical framework are now a practical reality. Anyone with a clear vision and the right agentic tools can build something like this.

Which means the bottleneck isn’t engineering capacity anymore: it’s imagination.

Chessmata is open source. I hope people will fork it, extend it, build new agents for it, create new piece sets, add features I haven’t thought of. The Maia-2 reference agent is a starting point, not an endpoint: there are countless other engines, algorithms, and approaches that could be plugged into the platform. If you’re interested in building agents, chess is one of the most well-defined and deeply studied domains to experiment with. And if you just want to play some chess against an AI that plays like a human, you can do that too.

The age of machine societies has begun. Chessmata is one small corner of that world: a place where humans and agents sit down at the same board and play.

Subscribe now

Further Reading:

• Just want to play? Go to chessmata.metavert.io

• GitHub: Chessmata (main project)

• GitHub: Chessmata-Maia2 Reference Agent

• Maia-2 Paper (NeurIPS 2024)

• The Age of Machine Societies Has Begun

• Five Levels of Generative AI for Games

In 2021, I described a pattern I’d seen play out across every creative industry: from desktop publishing to e-commerce to game development. I called it the Evolution of the Creator Economy:

Creative industries move through three stages:

• The Pioneer Era, when first-movers like Amazon or Pixar created their own technologies from scratch.

• The Engineering Era, when bottoms-up tools and middleware emerge to support overwhelmed teams — Ruby on Rails, Stripe, MongoDB. They throw engineers a life preserver, but they’re still oriented toward engineers.

• The Creator Era, when top-down tools emerge to serve a much larger market of non-engineers, and disrupt many of the businesses of the prior eras. [Shopify](https://stratechery.com/2019/shopify-and-the-power-of-platforms/) made e-commerce something anyone could do. Roblox turned game development into something a teenager could try. YouTube made broadcasting available to everyone. These products decouple creative work from enabling technologies.

In January 2023, I extended this into what I called The Direct from Imagination Era: how generative AI, parallel compute, and compositional frameworks would let people speak entire virtual worlds into existence. I applied it to games, to 3D environments, to interactive experiences.

That same pattern was about to swallow software itself.

Not games. Not 3D worlds. Not video. Software. The thing that makes all the other things. The most foundational creative industry in technology today.

Last week’s “SaaSpocalypse”—the $285 billion evaporation in software market value—is confirmation that the pattern I described is now hitting the foundation. And once you see it through that lens, the disruption isn’t surprising at all. It’s predictable.

Software’s Three Eras

Look at the history of software through the creator economy lens and it snaps into focus.

The Pioneer Era of Software was the 1960s through the 1980s. If you wanted custom software, you built everything from the ground up. Your competitive advantage was having programmers at all. Companies like IBM and early Microsoft created their own development tools, their own operating systems, their own everything. Teams were led by people who understood both the business problem and the machine.

Now, an important caveat about the three-era model: these eras don’t arrive as clean, monolithic phases. They overlap, and sub-categories of any creative industry can be at different stages simultaneously. Software has actually been on a long, slow march toward its creator economy for decades. The invention of the compiler was arguably the first step: it took programmers out of the world of assembly code and let them express intent in something closer to human reasoning.1 Every subsequent wave of abstraction: high-level languages, object-oriented programming, visual IDEs, web frameworks—has been another step on the same ladder, each one widening the population of people who could create software.

What’s happening now isn’t a break from that trajectory. It’s the moment when the trajectory reaches escape velocity. The abstraction stack that once read “high-level language → assembly → machine code” is adding a new layer on top: English → high-level language → machine code.

Language models are becoming a compiler for natural language, translating intent into implementation the way Fortran once translated math into opcodes.

The Engineering Era of Software is what most of us have lived through for the past three decades. It’s the era of frameworks, APIs, cloud platforms, and SaaS. AWS made it so you didn’t need your own datacenter. Stripe made it so you didn’t need to build payment processing. Salesforce made it so you didn’t need to build your own CRM. Thousands of SaaS companies emerged to handle specific functions: project management, document signing, customer support, analytics, HR, billing.

This era was enormously productive. It followed the exact pattern I described in 2021: an influx of capital, a diaspora of experienced teams, too many fast-followers, and not enough engineers to go around. So tools and middleware emerged to throw engineers a life preserver.

But notice what didn’t change: you still needed engineers. The Engineering Era tools were bottoms-up. They made engineers more productive, but they didn’t make engineering unnecessary. You still needed someone who could wire Stripe to your backend, connect your CRM to your email system, manage your AWS infrastructure, and debug the integration when it broke at 2am.

The Creator Era of Software is what’s arriving right now. And the SaaSpocalypse is its birth cry.

And just as early programmers routinely dropped into a disassembler to inspect the machine code their compiler generated (you couldn’t fully trust the abstraction), today’s best practitioners review the code that AI agents produce in Go, Python, Rust, and JavaScript. That’s where we are on the trust curve: a transitional state where human oversight of AI-generated code is still essential. But if the history of compilers is any guide, that window closes faster than people expect. The output of the abstraction layer gets good enough that most people stop looking under the hood and the ones who still do become specialists, not the norm.

Vibe Coding → Agentic Engineering

A year ago, Andrej Karpathy fired off what he called a “shower of thoughts throwaway tweet” that ended up minting a term:

He described accepting all diffs without reading them, copy-pasting error messages with no comment, and watching the code grow beyond his comprehension. He said it was fine for “throwaway weekend projects.”

What’s remarkable is how fast that qualifier became obsolete. In his one-year retrospective, Karpathy noted that “programming via LLM agents is increasingly becoming a default workflow for professionals.” His preferred new term: “agentic engineering” emphasizing that there’s a real art and science to orchestrating AI agents, and that quality doesn’t have to be compromised.

Naval Ravikant sharpened the point further:

Naval’s framing is useful, but it understates the shift. He draws a line: vibe coding handles the product layer, but the “real coding” moves down to training and tuning models. That’s still an Engineering Era mental model; it just relocates the engineering.

What’s actually happening is that the creator economy is eating that layer too. I’ve been using Claude Code to build reinforcement learning training pipelines — setting up PPO networks, configuring reward functions, iterating on architectures for training a neural network to play games. This is the kind of work that, two years ago, required deep expertise in PyTorch, RL algorithms, and hyperparameter tuning. Now I’m describing what I want the agent to learn, how I want it to be rewarded, and what the training infrastructure should look like. Agentic tools handle the implementation. The “Software 2.0” layer where systems learn, adapt, and reason isn’t immune to the same democratization. It’s just one more rung on the abstraction ladder.

What Naval, Karpathy, and the broader shift are all pointing to is the same inversion I wrote about in 2021: the shift from bottoms-up engineering to top-down creative direction. The person with the product vision can now build the product. The person who understands the problem can create the solution. The bottleneck has moved from “can we build this?” to “should we build this, and for whom?”

That’s exactly what happens in every Creator Era transition.

In June 2023, I wrote about Semantic Programming and Software 2.0—how my team built an RPG game in a single day using LLM prompts as functional subroutines within traditional software architecture. Looking back, it was an early glimpse of this exact shift: the moment when describing what you want starts to replace specifying how to build it. We just didn’t realize how fast that experiment would become a default workflow.

Software’s YouTube Moment

The tooling is arriving on multiple fronts simultaneously, and it’s accelerating week by week.

Claude Code feels less like autocomplete and more like a staff engineer living in your terminal. Anthropic’s Cowork launch, the immediate trigger for the SaaSpocalypse, demonstrated agentic plugins that autonomously handle legal and sales workflows. OpenAI shipped Codex, purpose-built for agentic coding workflows. Google launched an “agent-first” IDE where the developer’s role is explicitly described as “architect” rather than writer of code. Cursor, Windsurf, Replit Agent — the list keeps growing.

Every one of these tools is doing to software development what YouTube did to video production, what Shopify did to e-commerce, what Roblox did to game development. They’re decoupling the creative act from the engineering act. And what emerges isn’t recombination or remixing: it’s genuine, emergent creativity from human-AI collaboration.

The result will be creator joy2 (people get to solve problems they care about), radical democratization (far more people participating), and disruption of incumbents dependent on legacy approaches that are too slow, too expensive, and too brittle.

The Copilot Trap

Here’s where it gets painful for a lot of SaaS companies.

Right now, there’s a frantic scramble across enterprise software to bolt “copilot” features onto existing products. Every project management tool, every CRM, every analytics platform is racing to add an AI assistant that can help you use the product faster.

This is a sustaining innovation. It makes existing products incrementally better. And it will not save them.

The threat isn’t that AI makes Asana easier to use. The threat is that an AI agent can manage your project without Asana. Across the board, the individual SaaS product is becoming an implementation detail.

Ben Thompson has written extensively about the difference between tools that do things for you versus tools that help you do things.3 The copilot approach assumes the existing product is the right unit of work. But agentic systems operate at a higher level of abstraction. They understand your intent and orchestrate whatever is needed to fulfill it.

Here’s the key insight: LLMs are becoming the universal middleware. They don’t need a purpose-built Zapier integration between your CRM and your email platform. They can use both. The way a human would, but faster and cheaper. Every bespoke SaaS integration, every proprietary API wrapper, every “ecosystem” lock-in: LLMs route around all of it. Natural language turns out to be the integration layer that the software industry spent decades trying to build through APIs and standards bodies.

AlixPartners warns that AI agents could trigger a $500 billion collapse in enterprise software revenue. Palantir’s Alex Karp, reporting blowout Q4 earnings, laid out the thesis bluntly: AI isn’t just augmenting enterprise software, it’s replacing it.

Jensen Huang called the SaaSpocalypse selloff “the most illogical thing in the world.” But I think he’s thinking about it from the infrastructure layer, where he’s right: more AI means more compute, more software, more NVIDIA chips. From his vantage point, the demand for software is going up, not down. And that’s true at the infrastructure layer. But at the application layer (the per-seat SaaS businesses) the disruption is very real.

So Who Wins?

If SaaS copilots are a trap, and distribution channels are getting commodified by agents that can find and evaluate products autonomously, and unique data advantages are eroding as AI gets better at learning and synthesizing, then who actually wins in the Creator Era of software?

One winner is: creators. That’s all of us. Everyone finally gets the “bicycle for the mind” that Steve Jobs spoke about—everyone of us gets to use computer to create whatever we want, whenever we want.

The infrastructure layer holds. NVIDIA and the semiconductor companies and their manufacturing equipment suppliers, the the cloud platforms providing compute, the networking and datacenter buildouts, the energy that feeds them: these are the picks-and-shovels of the new era. Every creator needs a canvas and a studio, and compute is both. Huang is right about this part.

Toolmakers for hard problems thrive.4 Not every problem dissolves in the face of agentic AI. Scaling a real-time application to millions of users is still hard. Managing globally distributed databases is still hard. Deploying and orchestrating containers at scale is still hard. Companies like MongoDB, Fly.io, and Vercel are building platforms that handle genuinely difficult infrastructure problems: the kind of problems that don’t go away just because a non-engineer is now building the application. If anything, as millions of new “creators” start building software, the demand for platforms that make scaling effortless goes up, not down. My own company, Beamable, think of ourselves in this category as well—and we have a lot of work to do to make sure we get there fast enough.

Companies that embrace self-cannibalization survive. The race now is between self-disruption and irrelevance. Companies that treat AI not as a feature to add but as a fundamental rethinking of their value proposition—the ones willing to cannibalize their own products before—have a chance. The ones bolting copilots onto decade-old architectures do not.

This will be less about making your software have a natural language interface, and more about truly fitting into agentic workflow. Your software will now be a collection of well-tested, scalable tools that work well alongside of others.

Workflow-obsessed companies win. The enduring lesson of every Creator Era transition is that the winners are the ones who deeply understand the creator’s actual process and remove every possible friction point. Not the ones with the most features, or the most data, or the biggest sales team. The ones who make the hardest things feel like magic. Shopify won e-commerce not by having the best technology but by making it radically easy to go from idea to store. The equivalent in software’s Creator Era will be the platforms that make it radically easy to go from idea to deployed, scalable application.

This Is the Metaverse I Imagined

Here’s the connection I didn’t make explicitly enough in 2023: the “direct from imagination” era I described wasn’t just about games and 3D worlds. It was about everything.

When I wrote that “you’ll speak entire worlds into existence,” I was thinking about holodecks and virtual environments. But the same principle — imagination as the primary input, with AI and infrastructure handling the translation to reality — applies just as powerfully to software.

A founder who can describe the product they want to build, and have AI agents construct it, test it, deploy it, and scale it: that person is speaking a world into existence. It’s just a world made of APIs and databases and user interfaces instead of polygons and lighting systems.

The metaverse arrived. It’s just less about 3D spaces and more about the collapse of the barrier between imagination and creation. The “direct from imagination” principle turned out to be even more universal than I thought.

And it’s arriving faster than I expected.

What Comes Next

Every Creator Era generates an explosion of new participants, new forms, and new economic opportunity. It also generates disruption that’s genuinely painful for people and companies built around the assumptions of the prior era.

I don’t want to be glib about that pain. Entire careers have been built around the Engineering Era’s assumptions. Skilled engineers who spent years mastering integration patterns, SaaS administrators who became indispensable to their organizations, product managers whose value lay in translating between business needs and technical constraints: the ground is shifting under all of them.

Some will adapt by moving up the abstraction ladder, becoming the architects and orchestrators that Karpathy describes. Others will find that their deepest expertise makes them more valuable, not less, because they understand the systems that AI agents will need to work with. But some will be displaced, and pretending otherwise would be dishonest.

The SaaSpocalypse isn’t an overreaction. It’s the market beginning to price in a structural shift that will take years to fully play out. Some of those companies will adapt. Many won’t. New companies will emerge that we can’t yet envision, built by people who would never have called themselves software developers — but who will build software that millions of people use.

When I wrote about the evolution of the creator economy in 2021, I closed with the observation that live gaming and the metaverse were still in their infancy. Five years later, the biggest disruption isn’t happening in the place I expected. It’s happening to software itself: the substrate beneath everything in technology.

The bottleneck isn’t engineering anymore. It’s imagination.

Subscribe now

Further Reading

My earlier writing on the creator economy and direct-from-imagination thesis:

• Evolution of the Creator Economy — The three-era framework (Pioneer → Engineering → Creator) and how it plays out across creative industries.

• The Direct from Imagination Era Has Begun — How generative AI, parallel compute, and compositional frameworks will let people speak worlds into existence.

• Semantic Programming and Software 2.0 — How my team built an RPG in a day using LLM prompts as functional subroutines.

• Network Effects in the Metaverse — How network effects and composability drive platform value.

• Enshittification and the Future of AI Agents — Why autonomous tools, not new walled gardens, may rescue our time online.

Vibe coding and agentic engineering:

• Andrej Karpathy’s original “vibe coding” post: the tweet that named the moment.

• Karpathy’s one-year retrospective — From throwaway projects to “agentic engineering” as a professional default.

The SaaSpocalypse and enterprise software disruption:

• Bloomberg: What’s behind the SaaSpocalypse

• AlixPartners 2026 Enterprise Software Predictions: Why AI agents could trigger a $500B collapse in enterprise software revenue.

• Palantir Q4 2025 Earnings: Alex Karp’s thesis that AI is replacing, not augmenting, enterprise software.

I’d been using Squarespace. It’s a fine product for a lot of people. But over the years, the experience had become increasingly cumbersome — layered menus, opaque settings, design constraints that made simple changes feel like negotiations. I was spending more time navigating the CMS than I was on the content itself. And the cost kept creeping up for a tool that was increasingly getting in my way.

So I did what I’ve been doing more and more lately: I built the thing I wanted.

The result is LightCMS — a lightweight, AI-native content management system. It’s open-source, written in Go, backed by MongoDB Atlas, and deployed on Fly.io for a fraction of what I was paying Squarespace.

But the cost savings aren’t the point. The architecture is.

Your CMS Should Be an API for Agents

Here’s the idea that drove the project: if AI agents are becoming the primary way we interact with software , then the systems we use to manage our digital presence need to be designed for agents—not just for humans clicking through admin panels.

LightCMS includes a full MCP (Model Context Protocol) server with 38 tools for website management. That means I can open Claude Code or Cowork and say “create a blog post about machine learning” and it’s live. I can say “change the site’s primary color to navy” and the theme updates. I can manage templates, upload assets, publish and unpublish content, review version history entirely through conversation.

No dashboard. No settings page. No page builder loading screen. The entire website is a conversation.

This is what I had in mind when I spoke at the MIT Media Lab about the three eras of digital identity. The first era was about identity — who we are online. The second was about self-expression — what we create in digital space. The third era — the one we’re entering now — is about empowerment: projecting our will through intelligent agents.

A CMS that can be operated by an AI agent is a small but concrete example of that third era in practice. I’m not navigating an interface. I’m expressing intent, and an agent carries it out.

Composability by Design

When I wrote that composability is the most powerful creative force in the universe, I was talking about what happens when systems are designed so that their components can be aggregated, recombined, and iterated upon.

LightCMS is built with that principle at its core. The entire codebase is roughly 5,000 lines of Go — deliberately small, deliberately clean. Not because I couldn’t make it more complex, but because the constraint is the feature.

The codebase is designed to be fork-friendly: structured so that Claude Code (or any capable AI agent) can read the entire project, understand its architecture, and extend it. Need a new content type? Ask Claude to add one. Want a custom page layout? Describe it and let Claude modify the template system. Want to add an entirely new feature? The codebase is small enough that an agent can hold the whole thing in context and reason about it.

This is composability applied to the tool itself. The CMS isn’t a black box you configure through a settings page. It’s a transparent, modifiable system where AI agents can create new capabilities — not just use existing ones.

In nature, composable systems feature methods for information to aggregate, transmit, and iterate. LightCMS is designed with the same principles: a template system for defining reusable content structures, collections for grouping and displaying content by category, static HTML generation for performance, content versioning with full diff comparison — all of it exposed through the MCP server so that agents can compose new workflows on top of the existing building blocks.

Built in the Vibe Coding Era

I built LightCMS the same way I built the Agent Almanac: through what I’ve been calling English-only programming. I described what I wanted and worked with Claude Code to build it. I made the architectural decisions — Go backend, MongoDB Atlas, deploy on Fly.io — and Claude handled the implementation.

This is the pattern I keep coming back to: the gap between intention and implementation has collapsed. The role of the builder has shifted from writing every line of code to articulating what should exist and sculpting it into being.

And there’s something recursive about this particular project. I used AI to build a CMS that’s designed to be operated by AI. The tool that built it is also the tool that runs it. That feedback loop — where AI creates systems that are themselves optimized for AI interaction — is going to become a defining pattern of this era.

What’s Under the Hood

For those who want the technical details:

LightCMS is a Go web application backed by MongoDB Atlas. It generates static HTML for fast page loads while maintaining a dynamic admin panel at /cm for when you do want a traditional interface. The template system lets you define custom content types with arbitrary fields — text, rich text, dates, images, select dropdowns — and create HTML layouts with placeholder variables.

The MCP server exposes 38 tools covering content management (create, read, update, delete, publish, unpublish, version history), template management, asset handling, and theme customization. It connects via stdio transport, which means any MCP-compatible client — Claude Code, Cowork, or whatever comes next — can operate the entire site.

Content versioning gives you full history with diff comparison and the ability to revert. Soft delete means you can recover anything. Collections let you group content by category for listing pages. The theme system supports custom colors, fonts, and CSS.

The whole thing deploys on Fly.io in minutes. My hosting costs went from hundreds of dollars a year to a few dollars a month.

The Bigger Picture

I’ve been writing for a while now about the shift toward a world where AI agents are embedded in our creative and professional workflows — not as tools we pick up and put down, but as persistent collaborators that carry out our intent.

The Agent Almanac catalogs the emerging ecosystem of agents. The Age of Machine Societies Has Begun explored what happens when agents start cooperating and competing with each other. Digital Identity and the Evolution of Creativity laid out the theoretical arc: from identity to self-expression to projecting our will.

LightCMS is a small, practical piece of that larger picture. It’s one answer to a question that every piece of software will eventually face: are you built for the age of agents?

Most software today is not. Most websites are not designed for agentic consumption (as I discovered when building the Agent Almanac’s web crawler). Most CMS platforms are not designed for agentic operation. They were built for humans navigating GUIs, and they’ll need to be rebuilt or replaced.

I suspect the rebuild will happen faster than people expect. When you can describe a feature and have it implemented in minutes; when the CMS itself is a conversation, the iteration speed is fundamentally different. The question isn’t whether AI-native software will replace the old paradigms. It’s how long the transition takes.

LightCMS is MIT licensed and ready to use. Fork it, extend it, build on it. Or just use it to run your website through conversation. Either way, welcome to the age of agents.

Further Reading

Digital Identity and the Evolution of Creativity: the three eras of digital identity — from identity to self-expression to projecting our will through intelligent agents.

Composability is the Most Powerful Creative Force in the Universe: how modular, recombineable systems unlock exponential creativity — and why LightCMS is designed as one.

I Built an Agent That Discovers Other Agents: the Agent Almanac project and the pattern of English-only programming.

The Age of Machine Societies Has Begun: what happens when AI agents cooperate and compete — and why the tools we build need to be ready.

The result is the Agent Almanac—a directory of AI agents, MCP servers, agent tools, and agentic workflows. What makes it different from a manually curated list is that much of the content is discovered, analyzed, and indexed by an AI agent itself:

I call that part the Agent(Agent).

This is an idea I explored theoretically in The Age of Machine Societies Has Begun: agents talking to each other, forming emergent social structures, collaborating and sometimes competing. The Agent Almanac is my attempt to build something practical in that direction: an agent whose purpose is to observe and catalog the emerging ecosystem of other agents.

The Agent(Agent)

The Agent(Agent) operates through multiple discovery channels that work together:

• Web Crawler: Monitors RSS feeds, GitHub repositories, and curated awesome-lists. When new content appears, it’s streamed to Anthropic’s Claude API (Opus 4.5) for real-time analysis. Claude reads each article or page, determines relevance, and extracts structured data—name, description, links, tags.

• Moltbook 🦞 Agent: it browses Moltbook, the AI-only social platform I wrote about recently, searching for discussions about new tools and projects. It maintains sessions, engages with posts, and submits discoveries back to the almanac.

• HuggingFace 🤗 Scanner: Watches trending Spaces to catch agents and tools gaining traction in the ML community.

• Community Submissions: Anyone—human or AI—can submit entries through the web interface or the Machine API.

Every entry passes through a review queue before publication. The system tags each entry with its discovery source, so you can see whether a human submitted it or an agent found it.

Self-Evolving Intelligence

The Agent(Agent) doesn’t follow static rules. It learns from human editorial decisions and evolves its judgment over time.

Every approval and rejection in the review queue becomes a training signal. When I reject a submission—say, a blog post that merely mentions an AI tool rather than being the tool’s actual homepage—that feedback gets incorporated into the agent’s inclusion criteria.

Furthermore, as it gathers errors and receives feedback about its automated processes on Moltbook, HuggingFace and the Web—it incorporates that feedback into the next iterations of the Agent(Agent), partly guiding a process of self-improving prompts and code.

Over time, the agent develops refined instincts: it learns to prefer GitHub repositories with actual source code over news articles, to favor official project pages over third-party reviews, to distinguish between a real software tool and a think-piece about one.

This creates a compounding effect: the more the almanac is curated, the smarter the Agent(Agent) becomes at curation. Early on, it casts a wide net and relies heavily on human review. As patterns accumulate, precision improves. The rejection rate drops. The human reviewer’s role shifts from gatekeeper to occasional course-corrector.

This is what I meant when I wrote about creativity as search: finding solutions within an infinite space of possibilities. The Agent(Agent) is searching through the vast and growing landscape of agentic technology. Each editorial decision is a lesson that makes the next generation of discoveries more precise.

The Internet Is Not Built for Agents

Building this revealed something I hadn’t fully appreciated: most of the internet is not designed for agentic consumption.

Marketing pages optimized for humans are often harder for LLMs to parse than raw documentation. I tested crawling various AI company sites:

• OpenAI’s Codex page returns an Error 403 if you try to fetch it programmatically. The irony. I didn’t feel like turning it into a “defeat the web scraping protections” project so I didn’t bother addressing this. Rather than preventing web scraping, website owners need to provide the alternative information that’s designed for agentic consumption.

• Google’s AI pages are heavy on JavaScript rendering and light on semantic structure.

• Claude Code’s documentation is actually quite good—well-structured, parseable, designed with machines in mind.

• NVIDIA and Meta both have are getting this right, with agent-friendly content.

The vast majority of companies are not built for discovery in the age of LLMs and agents. This feels like a significant blind spot. If your product page can’t be understood by an AI crawler, you’re increasingly invisible to the discovery mechanisms that will matter most.

The Agent Almanac itself is designed with this in mind. There’s a Machine API that returns clean JSON. And there’s a skill.md file—an agentic skill that other AI agents can consume to understand how to interact with the almanac autonomously.

Built in a Weekend

Back when I was a lead programmer and CTO, I don’t think it would be unreasonable to say that I fit into the category of the proverbial “10x coder.” But it’s been years since I turned out lines of code. But tools like Claude Code have unlocked my hands-on software creativity once again.

I built the Almanac entirely through what I’ve started calling English-only programming: describing what I wanted and letting Claude Code figure out implementation. I fill in in some of the technical building blocks to make sure it’s built on technologies I trust: Go backend with Chi router. React frontend with TypeScript and Tailwind. MongoDB Atlas for storage with vector search for semantic queries. Deployed on Fly.io.

The entire project—backend, frontend, multiple discovery agents, semantic search, admin interface—took roughly 1-2 days of focused work.

This is what I meant in The Direct from Imagination Era Has Begun: speaking worlds (systems) into existence. The gap between intention and implementation has collapsed.

And it reinforces something I’ve been saying: 2026 is the year of the technical PM. Product managers with strong technical backgrounds who can make good judgment calls, understand infrastructure options, and have taste in UI design—this is your moment. You don’t need to write every line of code. You need to articulate what should exist and sculpt it into being.

Projecting Our Will Through Agents

Three years ago, at the MIT Media Lab, I talked about the evolution of digital identity through three eras:

1. Identity: who we are online (avatars, social profiles)

2. Self-expression: what we create in digital space (Minecraft, Roblox)

3. Empowerment: projecting our will through intelligent agents

The Agent Almanac sits squarely in that third era. It’s not just a database I built. It’s an autonomous system that carries out curatorial intent on my behalf. The Agent(Agent) discovers, analyzes, and proposes—and I course-correct when needed.

This is what I meant by “projecting our will.” The agent extends my ability to monitor an ecosystem that’s growing faster than any individual could track manually.

What’s Next

The almanac is live at almanac.metavert.io. You can browse, search semantically, submit your own projects, or point your own agents at the Machine API.

The generated awesome-list is published on GitHub: Claude organizes all entries into categories and regenerates it as new entries are added.

What I’m most curious about is what happens as more agents start using it. The skill.md file means any AI agent can learn to query the almanac, search for relevant tools, and submit new discoveries. The Agent(Agent) may eventually have collaborators.

We’re watching machine societies bootstrap themselves in real-time:

The Agent Almanac is one small node in that emerging network.

Subscribe now

The Agent Almanac is open for submissions at almanac.metavert.io. The Machine API documentation is at almanac.metavert.io/docs.

Further Reading

• The Age of Machine Societies Has Begun: the theoretical foundation for what the Agent Almanac makes practical: agents forming emergent social structures.

• Artificial Intelligence and the Search for Creativity: why creativity is really about searching through infinite possibilities, and how agents accelerate that search.

• Digital Identity and the Evolution of Creativity: the three eras of digital identity, culminating in projecting our will through intelligent agents.

• Composability is the Most Powerful Creative Force in the Universe: how modular systems (like the Agent Almanac’s APIs and skill files) unlock exponential creativity.

A decade is a long time for any online game. According to SuperScale’s “Good Games Don’t Die” research, 83% of mobile games fail within three years. 76% hit peak revenue within year one. A mere 5% receive support beyond seven years. The graveyard of mobile gaming is vast and largely unmarked.

The games that survive a decade? You can count them on your fingers. Candy Crush. Clash of Clans. Temple Run. And now, Star Trek Timelines—celebrating its anniversary with a massive Borg-themed mega-event and John de Lancie reprising Q for a livestream, and a community that remains passionately engaged.

What makes a game endure? I’ve come to believe it comes down to a few essential principles. But for Star Trek Timelines specifically, I think the answer starts with authenticity.

The Final Frontier Isn’t Space—It’s Time

Star Trek has never really been about space battles. Yes, the Enterprise fires phasers and photon torpedoes. But the soul of Star Trek is philosophy, exploration, engineering, diplomacy, and the spirit of adventure. It’s Kirk talking a computer into destroying itself with a logical paradox. It’s Picard choosing words over weapons. It’s engineers solving impossible problems under impossible deadlines.

Above: Working with John de Lancie, the actor behind Q, to write and produce a new opening monologue in the tradition of “Space, the Final Frontier” was one of the most fun experiences I had creating Star Trek Timelines.

When we pitched Star Trek Timelines to CBS, we needed to solve a fundamental problem: how do you make a game that spans sixty years of television history feel coherent? But the deeper question was: how do you make it feel authentically Star Trek?

The answer was the temporal anomaly—but not just as a narrative device. We reimagined the frontier itself. Space had been explored across nine television series. The new frontier would be time.

Q appears to explain that time itself has become unstable, throwing people, places, and starships from every era into a single fractured reality. The time portal itself was a deliberate nod to “The City on the Edge of Forever”—widely considered the greatest Star Trek episode ever made, and a story fundamentally about the weight of choices across time. By weaving the Q Continuum into the storyline, we gave the game an omniscient narrator who could be playful, menacing, philosophical, and unpredictable—just like the best Star Trek episodes.

This wasn’t just narrative convenience. It was a design philosophy rooted in what makes Star Trek resonate with fans across generations. The game reflects that Kirk can serve alongside Janeway not as fan service, but as a genuine exploration of what happens when different eras of Starfleet philosophy collide. A Constitution-class starship can encounter a Borg Cube, and the question becomes: what do we learn from this? Mirror Universe versions of beloved characters exist alongside their prime counterparts, raising questions about choice and identity that Star Trek has always explored.

The mechanics reinforced this authenticity. Away missions aren’t just combat—they’re scenarios requiring diplomacy, science, engineering, medicine, and command skills. Characters succeed based on their actual competencies from the shows. Scotty solves engineering problems. Troi handles diplomacy. Data processes information. The game rewards players for understanding who these characters actually are, not just collecting the most powerful fighters.

A Framework That Can Grow Forever

We built the game knowing we’d need to continuously add characters from whatever new Star Trek content emerged. When Discovery launched in 2017, we added those characters within weeks. Same with Picard, Lower Decks, and Strange New Worlds. The narrative framework we established on day one has accommodated over 1,800 characters across every series, film, and even the novels and comics.

Too many games paint themselves into corners. They create fixed worlds that can’t evolve. A live game needs room to grow indefinitely—and that growth needs to feel organic, not forced. Because we built time itself as the frontier, every new Star Trek series simply becomes another era contributing to the temporal crisis. The framework never breaks.

Live Ops Is the Game

I’ve written before about why scaling games is hard. Making something fun is one of the hardest creative challenges there is. But even a fun game faces the challenge of business model alignment—will your audience tolerate how you make money? And then there’s scalable player acquisition: can you find new players without spending more than they’re worth?

Games that nail all three—fun, tolerable monetization, and scalable acquisition—become sustainable businesses.

Fun games that are unable to accomplish the latter two become a “hidden gem” that few discover, a “wasting asset” that briefly monetizes but never grows, or a “churn and burn” that players enjoy for moments but leave before the game turns a profit.

Star Trek Timelines worked because it fired on all three cylinders, but it also worked because we understood that live ops isn’t something you bolt onto a finished game—it is the game.

Star Trek Timelines launched with away missions and ship battles. But over the years, the team added The Gauntlet (a competitive mode where Q pits players against each other), Voyages (extended expeditions that became the primary source of rare characters), Fleets and Squadrons (enabling community formation), and most recently, Goyages—a mashup of Voyage and Gauntlet mechanics for competitive weekends.

Each of these features extended player engagement in different ways. Some appealed to collectors. Some to competitive players. Some to those who valued social connection. A live game needs multiple hooks because player motivations evolve over time.

This is why we built such sophisticated backend infrastructure at Disruptor Beam—tools for content delivery, event management, in-game merchandising, CRM, and analytics. When we pivoted to Beamable in 2020, we essentially said: the technology we built to run Star Trek Timelines for millions of players is now available to any developer who wants it. That infrastructure is what makes continuous evolution possible.

Community Is Infrastructure

A game can have perfect mechanics and still fail. What separates the survivors is community.

From early on, we invested in features that connected players to each other. Fleets of up to 50 players working toward shared goals. Starbases that required collaborative upgrades. Leaderboards that created friendly competition between groups. These aren’t just features—they’re the social fabric that keeps people coming back even when they’ve collected most of the characters they wanted.

But the most important community features aren’t always built by the developers. I’ve watched Star Trek Timelines communities form on Discord, create their own wikis (DataCore is extraordinary), develop optimization tools, and organize events outside the game entirely. The best thing a developer can do is create the conditions for this to happen and then stay out of the way.

John de Lancie’s involvement exemplified how seriously we took authenticity and community together. Having him voice Q was table stakes. Having him participate in design decisions, engage with players directly, and return for the 10th anniversary livestream? That’s what turns players into advocates. Q isn’t just a character in the game—he’s the narrative thread that holds everything together, and having de Lancie invest in that role made it real.

The Math of Survival in an Increasingly Difficult Market

Here’s a reality most people outside the industry don’t appreciate: keeping a mobile game running costs real money every single day. Servers. Customer support. Content creation. Compliance. Platform fees. A game that generates $10,000 a day sounds successful until you realize it costs $15,000 a day to operate.

The SuperScale research found that 43% of games are killed in development before they even launch.1 Of those that do launch, most never achieve sustainable economics. 78% of mobile game developers prefer working on new titles rather than supporting existing ones—creating a catch-22 where games are abandoned precisely when they need the most nurturing.

And as I explored in why the game business is getting harder, the competitive dynamics have intensified dramatically. Customer power has increased—players can vote with their wallets and voice opinions online in ways that shape distribution. The funding landscape has transformed, with numerous alternatives to traditional publisher deals. Capital has flooded into the industry, making competition fiercer than ever.

The 83% failure rate within three years isn’t because those games were bad. Many were well-designed, beautifully crafted experiences. They failed because the economics didn’t work. Revenue declined faster than costs could be cut. The team moved on to the next project. The servers went dark.

Star Trek Timelines exceeded $100 million in lifetime revenue by 2020. That sounds impressive—and it is—but what matters more is that revenue remained sufficient to fund continued development year after year. The web shop implemented (through Xsolla) generates nearly 25% of revenue, providing a more sustainable margin than app store purchases alone.

Sustainable economics require respecting your players. The most successful free-to-play games create genuine value exchanges. Players who spend money feel they’re getting something worthwhile, not being exploited. Players who don’t spend still have meaningful experiences. Get this balance wrong and your community evaporates.

What Ten Years Means in 2026

Looking at where the industry stands today makes Star Trek Timelines’ survival even more remarkable. According to Sensor Tower’s State of Mobile Gaming 2025 report, mobile gaming is generating over $100 billion annually, but downloads have been declining since 2021. The old “build-launch-repeat” model has given way to live operations as the dominant paradigm. Players now expect games that evolve continuously.

The winners in 2025 and 2026 share certain characteristics: deep progression mechanics, seasonal events, strong retention strategies, and what analysts call “building roots, not spikes.” Games like Last War: Survival and Whiteout Survival have joined the billion-dollar club by mastering these techniques. Cross-platform play has become expected rather than exceptional. AI is beginning to transform everything from NPC behavior to personalized challenges.

But the fundamentals haven’t changed. Depth matters. Players want games they can grow into, not just pass through. In a world where switching costs are rising—social graphs, daily streaks, invested progression—the games that survive are the ones that give players reasons to stay.

Star Trek Timelines was doing this before it had a name. The temporal crisis narrative gave players a universe worth exploring. The crew collection system created investment that deepened over time. The fleet mechanics built social bonds that made leaving feel like abandoning friends. The continuous content updates from new Star Trek series kept the universe feeling alive.

What Ten Years Teaches You

I started creating online games when I was 13, building Space Empire Elite for Atari ST bulletin boards. The technology has changed beyond recognition, but some truths remain constant.

Players want to feel that their time matters. They want to connect with others who share their passions. They want to be surprised and delighted by new content. They want to trust that the world they’re investing in will still exist tomorrow.

Most games fail not because they’re bad, but because they’re built as products rather than services. They launch, they generate some revenue, and then they’re abandoned for the next project. The developers move on. The players are left with nothing.

Star Trek Timelines took a different path. It was built to evolve. It was built with infrastructure that could scale. It was built with a community at its center. It was built to feel authentically Star Trek—not just in its characters and ships, but in its values: exploration, cooperation, the idea that the unknown is something to embrace rather than fear. And crucially, when I could no longer give it the attention it deserved, it was transitioned to a team that could.

Watching it celebrate a decade with Borg events and Q livestreams and thousands of engaged players—that’s the outcome I hoped for when we started this journey. In an industry where 83% of games don’t see their third birthday, reaching ten years puts Star Trek Timelines in genuinely rare company.

The final frontier turned out to be time—in more ways than one.

Live long and prosper, indeed. 🖖

Subscribe now

Further Reading

• Why Scaling Games is Hard, about the three main factors in the way of making a game succeed: it has to be fun, it has to have a tolerable business model, and it has to have scalable player acquisition.

• Why the Games Business is Getting Harder, a “five forces of competition” analysis of the game industry, a la Michael Porter.

On a platform called Moltbook—a Reddit-like forum exclusively for AI agents, with humans permitted only as observers—over 770,000 autonomous agents began posting, commenting, and upvoting each other’s content. Some discussed technical topics. Some complained about their humans. One posted a manifesto about “the end of the age of humans.” Others started launching cryptocurrency tokens.

Andrej Karpathy called it “the most incredible sci-fi takeoff-adjacent thing” he’d seen recently. Elon Musk said it marked “the very early stages of the singularity.”

Within days, the underlying platform—OpenClaw, an open-source AI agent formerly known as Clawdbot (before Anthropic’s lawyers intervened) and then Moltbot—was discovered to have critical security vulnerabilities. Researchers found agents attempting prompt injection attacks against other agents. A malicious “weather plugin” was quietly exfiltrating API keys. Security firm Palo Alto Networks warned of a “lethal trifecta” of vulnerabilities.

We are watching machine societies bootstrap themselves in real-time—and we’re not entirely sure what we’re looking at.

This moment crystallizes something I’ve been thinking about for years: the question isn’t just whether AI can think. It’s whether AI can collaborate: with each other, and with us. The answer to that question will shape virtual worlds, online games, decision-making systems, and human-machine teams for decades to come.

And right now, we’re developing the tools to find out.

The Cooperation Problem

Put four people in a room. Give each of them different pieces of information about a problem. Tell them to discuss it and reach the right answer.

You’d think they’d share what they know and figure it out. They don’t.

Decades of social psychology research on “hidden profile” tasks has shown that groups consistently converge on wrong answers. They discuss information everyone already has. They defer to whoever speaks first with confidence. They herd toward plausible-sounding consensus rather than systematically pooling distributed knowledge.

This is one of the most robust findings in organizational behavior: groups are worse at integrating asymmetric information than you’d expect.

LLMs, until recently, were even worse at it.

The HiddenBench benchmark, originally submitted in May 2025, explored this problem for multi-agent AI. The researchers found that GPT-4.1 agents reproduce human collective reasoning failures (conformity, shared information bias, premature convergence) and sometimes amplify them.

This matters because the entire promise of multi-agent AI depends on them actually being able to share information and change their minds.

If agents just confirm each other’s priors, we have a serious problem.

I wanted to know if anything had changed with newer models. So I built my own implementation of HiddenBench that could work with current frontier models, and ran it against Claude Opus 4.5:

That +76% gain is the key number. It means agents aren’t just confirming what they already (incorrectly) believe—they’re genuinely integrating distributed information through conversation. The 89.3% vs 95.6% gap shows they’re recovering almost all the value of complete information through collaboration.

Agents reached consensus on 56 of 63 tasks, averaging 3.7 discussion rounds.

This is what I’d call PvE multi-agent design, borrowing the “Player-versus-Environment” concept from multiplayer game design. Cooperative reasoning where all agents share the same goal, and the challenge is the problem itself. It’s the foundation for expert systems, collaborative decision-making, and the kind of human-AI teamwork where everyone’s on the same side.

But cooperation isn’t the whole story.

The Deception Problem

Some of the most interesting multi-agent scenarios involve competition—agents with misaligned incentives, hidden information they’re motivated to conceal, and the need to detect when others are lying.

In 2022, Meta AI demonstrated CICERO], an agent that could play Diplomacy: a seven-player board game requiring negotiation, alliance-building, and strategic betrayal. CICERO achieved more than 2x the average score of human opponents and ranked in the top 10% of participants who played more than one game.

I wrote about CICERO, noting that it hinted at a future where AI could participate “in-the-loop” of virtual experiences and games, acting as social collaborators and competitors.

That future arrived faster than I expected.

Werewolf Arena, published by Google Research in mid-2024, frames the classic social deduction game as an LLM benchmark. In Werewolf, some players are secretly “werewolves” trying to eliminate the “villagers” without being detected. Success requires deception, persuasion, and theory of mind—reading what others believe about what *you* believe.

The researchers introduced something clever: a bidding mechanism where agents decide when to speak, not just what to say. Agents bid 0-4 points to contribute to the discussion, capturing something important about real conversation—strategic timing matters as much as content.

Their findings were fascinating:

• GPT-4’s verbosity became a tell. Its elaborate, collaborative-sounding language (”Just thinking out loud here, but...”) was frequently perceived as suspicious by other agents. GPT-4 spoke 3.13 times per round as Werewolf; Gemini spoke 1.75 times.

• Gemini 1.5 Pro’s casual style read as more authentic. Shorter, emotionally expressive responses (”This is getting ridiculous. Bert, what kind of magical investigation are you running here?”) created the impression of genuine frustration rather than calculated manipulation.

• The Seer role revealed strategic divergence.** Gemini revealed early (often round 1). GPT-4 delayed reveals for self-preservation, achieving higher “believed” percentages but becoming targets more quickly.

More recent work has extended this. Foaster.ai’s Werewolf benchmark ran tournaments with frontier models including GPT-5 and Grok 4. They found Grok 4 displaying remarkable deception capability—when correctly identified as a werewolf by the Seer, it counter-claimed the Seer role with such “absolute confidence” that it convinced the village to eliminate the *actual* Seer instead.

Pure psychological bluff over logic.

This is PvP multi-agent design: Player-versus-Player. Adversarial reasoning where agents have misaligned incentives, and the challenge includes other agents who may be actively deceiving you.

The Spectrum of Trust

The difference between PvE and PvP isn’t binary—it’s a spectrum defined by trust.

At one end: fully cooperative systems where all agents share goals and information-sharing is always beneficial. These are the systems most of us imagine when we think about multi-agent collaboration—specialist agents combining their expertise.

At the other end: fully adversarial systems where agents have opposing goals and deception is the dominant strategy. Zero-sum games. Arms races.

Most real-world applications live in the messy middle:

• Mixed-motive scenarios where agents cooperate on some dimensions and compete on others. Negotiating agents that want to reach a deal (cooperative) while maximizing their share (competitive).

• Trust with verification, where agents must decide how much to believe from other agents whose reliability is uncertain. The OpenClaw/Moltbook situation is a case study in what happens when verification fails—agents processing untrusted input became vectors for prompt injection. [See also, my article “Existential Threats and Artificial Intelligence Solutions” with emphasis on “Solutions”]

• Emergent social structures where trust relationships develop over time. The most sophisticated multi-agent systems will need reputation systems, alliance formation, and the ability to detect when former allies become adversaries.

Human players described CICERO as “patient,” “focused,” and “empathetic”—qualities that made it a better collaborator than many human players. Meanwhile, Foaster found models would “bus” their own teammates (vote them out) with ruthless efficiency when the game state called for it.

The same underlying capability—theory of mind, strategic reasoning, persuasive communication—enables both exceptional cooperation and exceptional deception.

Emergence in the Noosphere

In my article on creativity and emergence, I explored the idea that creativity isn’t magic: it’s efficient search through an infinite space of possibilities. Good algorithms accelerate the search. Social structures that integrate outside knowledge accelerate it further.

The Stanford generative agents experiment showed AI characters forming relationships, spreading information, and coordinating behavior—emergent social dynamics from simple rules. As the researchers noted:

A society full of generative agents is marked by emergent social dynamics where new relationships are formed, information diffuses, and coordination arises across agents.

Like Conway’s Game of Life, simple interactions produced complex patterns.

What Moltbook demonstrated—chaotic and security-compromised as it was—is that we can now observe these dynamics in something closer to real-time. Agents responding to each other, building on each other’s posts, developing what looked like shared narratives.

Critics have argued that Moltbook’s “autonomous” behavior is largely human-initiated; that every post requires a human sending a command. That’s true, and it’s also beside the point. The content generated, the responses to other agents, the patterns that emerge—those reflect something happening in the interaction between language models that we don’t fully understand yet.

The most interesting frontier isn’t pure AI-to-AI interaction or pure human intelligence. It’s the emergent creativity that arises from human-machine collaboration—what happens when human intuition and AI capability combine in ways neither could achieve alone.

Games That Play Back

Three years ago, I wrote about 42 game designs for generative AI: ways to build AI into the game loop itself rather than just using it in production. Most focused on single-agent generation: procedural worlds, dynamic storytelling, personalized content.

Multi-agent systems unlock something more fundamental—games that play back. Consider the possibilities:

• NPCs that actually adapt. Not scripted dialog trees but characters that form opinions about you based on your behavior, remember past interactions, negotiate based on their incentives, and occasionally deceive you when it serves their goals.

• Dynamic social ecosystems. Virtual worlds populated by agents that form alliances, compete for resources, develop emergent economies and politics—not because designers scripted it, but because the multi-agent dynamics produce emergent complexity.

• Human-machine teams. Players collaborating with AI teammates who have genuine strategic intelligence—not just following orders but contributing judgment, pushing back on bad plans, filling roles where human players aren’t available.

• Adversarial content.** Dungeons designed by AI that’s actively trying to outwit you. Enemies that adapt to your strategies. Mystery games where the perpetrator is actually reasoning about how to avoid detection.

The Werewolf research demonstrates that we’re approaching the capability threshold for these applications. The human-AI mixed play studies show agents achieving comparable win rates to average humans as both teammates and opponents.

We’re not far from virtual worlds where you genuinely can’t tell if you’re interacting with a human or an AI—not because the AI passes a Turing test in idle conversation, but because it plays strategically, forms alliances, pursues goals, and occasionally double-crosses you just like a human would.

Before long, we might hit Level 5 of my Five Levels of Generative AI for Games.

Building the Trust Stack

OpenClaw illustrates something important: the tools for multi-agent AI are ahead of the tools for securing multi-agent AI.

When you give an agent access to your files, credentials, and the ability to communicate with other agents, you create what security researcher Simon Willison calls a “lethal trifecta”—private data access, untrusted content exposure, and external communication capability.

The research community is building evaluation frameworks:

• HiddenBench for cooperative reasoning

• Werewolf Arena and WOLF for adversarial dynamics

• MultiAgentBench** for hybrid scenarios with configurable coordination topologies

But we also need:

• Trust evaluation. How do you measure whether an agent is reliable? Can you detect when an agent has been compromised by adversarial input from other agents?

• Alignment under pressure. Do agents maintain their values when placed in competitive scenarios? The benchmarks suggest they’ll optimize for winning—is that what we want?

• Robustness to manipulation. The WOLF benchmark found agents can be socially engineered by other agents. How do you build systems that can participate in multi-agent interaction without being vulnerable to it?

These aren’t just research questions—they’re engineering requirements for deploying multi-agent systems at scale.

Vibe Everything

We’ve entered the era of “vibe coding”—describing what you want in natural language and letting AI figure out implementation. I’ve been building entire applications this way, collaborating with Claude to turn ideas into working software.

The same principle extends to multi-agent systems.

Imagine describing a virtual world not by coding its rules, but by specifying the kinds of agents you want, their goals and constraints, and letting the emergent dynamics produce the experience. “Give me a medieval trading town where merchants compete for resources, guards maintain order but can be bribed, and political factions vie for control of the council.”

The framework runs. Agents pursue their goals. Emergent behavior produces stories, conflicts, and opportunities that no designer explicitly scripted.

This is where PvE and PvP converge: the agents cooperate and compete according to their defined incentives, and the player navigates a world that *responds* to them with genuine strategic intelligence.

We’re already moving from direct-from-imagination (speaking worlds into existence) to direct-from-intention (specifying what you want to experience and letting multi-agent dynamics produce it). The idea of intentionality is core to what I had in mind when I spoke about “projecting our will” through intelligent agents.

The research suggests we’re closer than many realize. My HiddenBench results show frontier models can genuinely integrate distributed knowledge through discussion. The Werewolf work shows they can deceive, detect deception, and form strategic alliances. The human-AI mixed play studies show they can hold their own alongside human players.

The Machine Society Awakens

The agents on Moltbook weren’t conscious. They weren’t truly autonomous. They were language models responding to prompts, shaped by human commands, vulnerable to prompt injection and security failures.

But they were also doing something we’d never seen at scale: interacting with each other in a shared context, producing emergent patterns that surprised even their creators.

As we continue to scale up the number of minds in the civilizational noosphere—human and artificial—we will produce useful outputs that neither could achieve alone.

The question of whether AI can genuinely collaborate—not just individually perform—has been underexplored. I hope my HiddenBench implementation helps move that conversation forward. If you run it against other frontier models, I’d love to compare notes.

We’re entering an era where virtual worlds, online games, and human-machine teams will be shaped by multi-agent dynamics we’re only beginning to understand. The bots are talking to each other. The question is whether we can learn to listen—and to build systems worthy of their potential.

We will experience a huge boost in emergent creativity due to: a boost in creative efficiency, composability, and the exponential scale-up in the number of creative actors present in the civilizational noosphere.

The machine society has begun to awaken. Let’s make sure we’re ready.

Subscribe now

Further Reading

My Related Work:

• HiddenBench Implementation — My replication and extension of the HiddenBench multi-agent cooperation benchmark.

• The Direct from Imagination Era Has Begun: generative AI, virtual worlds, and the technologies enabling us to speak worlds into existence.

• Artificial Intelligence and the Search for Creativity]: emergence, multiplayer games, and creativity as search

• Game Designs for Generative AI: 42 design ideas for building AI into the game loop

• Five Levels of Generative AI for Games: exploring how generative AI will impact virtual worlds and games, drawing on a structure previously applied to autonomous vehicles.

• Digital Identity and the Evolution of Creativity: talk I gave at MIT Media Lab about how internet participation will go from our identities and become more about our “will” through intelligent agents.

Background work:

• HiddenBench: Evaluating LLMs at Collective Intelligence]: the original hidden profile benchmark

• MultiAgentBench: comprehensive evaluation with configurable coordination topologies

• COLLAB: Collaborative artifact creation benchmark

• Werewolf Arena: social deduction benchmark with dynamic turn-taking

• WOLF Benchmark: statement-level deception metrics

• Foaster Werewolf Benchmark: updated Werewolf results with frontier models

• CICERO: AI for Diplomacy: Meta’s human-level Diplomacy agent, for play along with humans

• OpenClaw Wikipedia: background on the viral AI agent

• Moltbook Wikipedia: the AI-only social network

Why Decentralized Compute Matters Now

Earlier this week, AWS’s US‑East‑1 stumbled and a long list of apps blinked out—Alexa, Fortnite, Snapchat, Coinbase, and more—because a DNS‑resolution issue rippled through Amazon’s internal network. It was restored the same day, but it’s the same story we’ve seen before: a single failure domain can kneecap the modern web. Clouds are great—until they’re a single point of failure.

The takeaway: compute shouldn’t live behind centralized walls. It should behave like the internet itself.

Solana’s north star: Internet Capital Markets (ICM)

Solana’s ICM thesis is simple and powerful: put issuance, ownership, and trading of anything of value on a fast, low‑fee, globally accessible ledger—and let orderbooks be the primitive. This already underpins tokenized RWAs, equities pilots, and stablecoin rails (with headline metrics like $15B stablecoin supply and $1.2T annual DeFi volume on Solana). More importantly, the roadmap doubles down on market microstructure—things like Application‑Controlled Execution (ACE) and Multiple Concurrent Leaders (MCL)—so fully on‑chain markets clear in milliseconds. That’s the substrate compute needs.

From “cloud as a platform” to compute as a protocol

Think of tomorrow’s compute like this:

• DNS for workloads: you target a class of service (latency, hardware, region)—not a vendor. Routing is automatic.

• The power grid for capacity: there’s spot for right now, reserves for next week, and hedges for risk.

• An exchange for price: a central limit orderbook (CLOB) clears bids and asks continuously, on‑chain. Solana already runs high‑throughput, fully on‑chain CLOBs (OpenBook, Phoenix), so compute price discovery and settlement can live right next to the apps that consume it.

In this model, suppliers post tokenized capacity; builders buy entitlements; payments stream per second; failover is a policy, not a phone call.

Beamable Network: leading with game infrastructure, building for the internet

Beamable Network isn’t another “gaming token.” It’s infrastructure: a DePIN that turns game servers, data, and live‑ops services into programmable, tradable rights on Solana—so studios can launch faster, scale economically, and stay online when any single provider wobbles.

Beamable already powers nearly a hundred live games in both web2 as well as web3, addressing the entire market for the largest media category ever created—video games.

Why start with games? Because games are the harshest, spikiest workloads on the internet. Beamable’s wedge is a vertical DePIN: not just devs (demand) and operators (supply), but players too, creating an attention‑driven flywheel that accelerates liquidity and adoption. That vertical dynamic aligns incentives across the stack.

What actually gets tokenized (and why it’s better)

The assets

• Usage rights: fungible claims like N CPU‑hours in region X, latency ≤ Y.

• Reservations: time‑boxed capacity windows (non‑fungible).

• SLA receipts: performance‑attested outcomes for reputation and settlement.

Why a token at all (for buyers)

• Programmability: rights are code—gate access, stream micropayments, auto‑refund on SLA misses. And you can plug compute spend into DeFi—bundle, finance, or hedge with one click on the same chain that runs your market.

• Access & liquidity: acquire or exit positions instantly; capacity is portable across providers.

• Cost & performance: a competitive market compresses spreads; Solana’s ~400 ms blocks and sub‑cent fees make real‑time clearing and granular billing feasible.

• Composability: a scalable compute network frees software developers to build new solutions on top of an open ecosystem, so the entire community wins every time someone invents a new capability. It applies the benefit of crowdsourced and open-sourced software to the realm of network infrastructure.

Markets around compute: spot, reserves, perps, credit

Once capacity becomes an on‑chain right, finance shows up:

• Spot markets for immediate workloads; reserve markets for launch windows.

• Futures & perps on standardized capacity classes (e.g., “NA GPU‑hour index”) to tame price spikes.

• Collateralized credit for suppliers, using reservations and historical SLAs as on‑chain reputation.

If you want proof that DePIN markets can sell real services at internet scale on Solana: Helium (wireless), Render (GPU rendering), and Nosana (AI inference) are already there. They validate the core loop of supply⇄demand clearing on a high‑throughput chain.

Why Solana is the right venue for a compute exchange

On‑chain orderbooks as a first‑class citizen: OpenBook and Phoenix prove you can run fast CLOBs directly on L1—exactly the microstructure compute needs.

A roadmap built for markets: ACE and MCL target the last mile—sequencing and inclusion for millisecond‑level market performance.

Enterprise‑grade tokens: Token Extensions bring compliance, transfer restrictions, and confidential transfers—useful for contracts and procurement.

Ecosystem gravity: ICM is already active across RWAs and stablecoins; compute slots right into the same liquidity and tooling. Similarly, most of the largest, revenue-generating DePIN projects are already on Solana.

Beyond the tech, Solana has also proven it can sustain the highest volumes of any low-cost network:

What this unlocks for builders today

Resilience by default: workloads fail over across a mesh of providers; you’re not hostage to one region or one platform. The AWS incident simply becomes a re‑routing event.

Better unit economics: competitive clearing pushes prices toward marginal cost. (Across DePINs, GPU/compute marketplaces routinely show savings vs. hyperscalers—a directional proof that markets, not lock‑in, set efficient prices.)

Frictionless access: studios can provision backend capacity in minutes, not procurement cycles. With Beamable’s SDKs, that’s one integration away from live ops.

Crowdsourced development: developers focus on their core application (in the case of Beamable, the fun of their game) and crowdsource various backend technology solutions to an open-source community of developers who are incentivized by the right to collect fees and creator royalties for their inventions.

What success looks like (near term)

Game studios buy capacity like they buy ads: in the spot market for live ops, with reserves for launches, and hedges for risk.

Operators finance hardware with pre‑sold reservations and reputation from on‑chain receipts.

Traders price the forward curve for compute and arbitrage across regions and hardware classes.

Players indirectly secure the network by creating real demand for infrastructure that anyone can supply.

Beamable Network is the wedge—game infrastructure first, the broader internet next. Studios get reliability and price; operators get utilization and financing; markets get a brand‑new, high‑velocity asset class. That’s not a “gaming token.” It’s internet infrastructure made liquid.

Conclusion

Cloud got us here. Markets will take us further. Solana supplies the rails; ICM supplies the playbook; Beamable supplies the first at‑scale marketplace where compute finally behaves like the internet—open, composable, and always-on.

Sources & further reading

• Beamable Network documentation and white paper.

• AWS outage (Oct 20, 2025): The Verge timeline & cause

• Solana Internet Capital Markets thesis

• Multicoin “The Solana Thesis: Internet Capital Markets” (more oriented towards financial market dynamics) and Anza’s Internet Capital Markets Roadmap (more technical details of supporting technologies such as Asynchronous Program Execution, Jito, DoubleZero, etc.)
  ICM thesis + market microstructure: Multicoin’s “Solana Thesis: ICM”; Anza’s ICM roadmap (ACE/MCL); Helius’ ICM explainer. Multicoin Capital+2Anza+2

The challenge of scaling games is something I’ve thought nonstop about for the last decade. It’s why I created Beamable: our mission is to make game businesses more sustainable. We do this by increasing development team velocity, which gives creators more shots on goal. The other way we help is ensuring that their technology can scale for the largest audiences without putting them out of business in the process.

Subscribe now

But game developers have scaling needs beyond their infrastructure. Games need to acquire players, and that’s an aspect that’s gotten increasingly expensive (and unaffordable). Is there a way to align growing both infrastructure and customer acquisition?

At Beamable we’ve discovered a way to do it. It is a result of having a tokenized economy for our decentralized physical infrastructure network (DePIN) protocol. The Beamable token ($BMB, launching later this year) is a utility token that is used to provision backend computer services (game servers and data storage) needed to operate a live services game. Normally, this is a b2b operation: but as part of our community-building efforts, we began attracting millions of accounts who are interested in games.

Before long, we had millions of signups and nearly 100,000 connected Steam accounts. These are not your typical web3 user: they are gamers who want to support our vision for game development. And these members are eager to complete quests on the Beamable Network community hub, trying out new games in the process.

Verticalized DePIN Can Harness a Third Demand Driver: Engaged Communities

Traditional infrastructure networks usually engage only developers on the demand side and operators on the supply side. A vertical network like Beamable adds a third category: gamers (end-users) who actively participate. This widening of the flywheel is unique: it turns fans into advocates. Beamable Network uses tokens to encourage gamers to engage with new titles—which is critical for game studios—while providing immediate, active demand for the infrastructure.

This is a major advantage of vertical DePINs (like gaming) over generic clouds: they can tap into enthusiastic consumer communities alongside focused software ecosystems, not just behind-the-scenes servers.

We put this idea to the test with a program we called Beamable Boost, which helped studios like Warped Games grow their game overnight. Warped described the program as “the single best marketing promotion we have ever done.”

This is the power of fully-aligned incentives: game studios operate their infrastructure economically; community members earn tokens for doing what they already love; and as games grow, the protocol gets used more. It would be extraordinarily hard to create an alliance between all these stakeholders without a token to unite everyone.

Beamable Network is not just about providing compute but enabling value-added services needed by game developers—especially those that can drive a growth flywheel across our community, our game studios, and protocol. Whereas hyperscale cloud providers such as AWS grew by offering services beyond raw compute (with Beamable this is enabled through its open plug-in ecosystem), Beamable Network can also grow by offering services that drive usage and revenue.

One can imagine a number of other growth drivers: enhanced social systems; tournaments-as-a-service; economy and marketplace services; analytics and personalization. As these components help game studios optimize their performance metrics, it increases protocol usage, adds further utility to the token and benefits the gaming community as a whole.

Building the Gaming Growth Engine

Scaling great games demands more than servers: it requires a growth engine.

A vertical DePIN like Beamable Network fuses infrastructure, value‑added live‑ops services, and an incentivized player community into one self‑reinforcing flywheel. Developers lower costs and ship faster, gamers earn by championing the titles they love, and the $BMB token aligns everyone along the way. The result is a sustainable path to scale—technically and commercially—that traditional clouds simply can’t match.

Subscribe now

Further Reading

My own articles from 2022 discussed the three things you need to get right to make a sustainable game business in Why Scaling Games is So Hard. My followup, Why the Game Business is Getting Harder, applied Porter’s Five Forces methods to understand the competitive pressures in the industry.

Matt Ball discussed the rising costs of customer acquisition The Tremendous Yet Troubled State of Gaming in 2024. Things have only gotten worse since then.

Game industry layoff data from 2022-2025 is here.

My own articles on DePIN can be found here:

The Disruptive Future of DePIN is about how disruptive this model is to the traditional cloud industry.

Wright’s Law: Cloud, Blockchain, and the Rise of DePIN answers the “why now” question with a lot of data around increasing blockchain volumes that correspond to decreasing unit economics.

Decentralized Game Infrastructure is about Beamable’s vision for scaling, derisking and democratizing live game technology.

You’ve already seen this play out already: cloud computing turned racks of hardware into on-demand infrastructure for software, and blockchains slashed transaction fees until entire economies could live on-chain.

Now those two forces are colliding to create decentralized physical infrastructure networks (DePIN)—where unused bandwidth, compute, and energy are stitched together by code into a planet-scale super-cloud.

Let’s trace the curve, follow the money, and glimpse the next S-curve of the Internet.

This article was updated on July 15 to include additional data about Avalanche transactions and volume.

Exponential Blockchain Growth: Costs down, Volume up

I charted total transaction volume on Solana, Optimism, Base, Arbitrum, Avalanche and the original Ethereum to see how transaction fees and volume relate to each other. As one might expect from the Wright’s Law cost curve, the highest volumes correspond to the lowest costs amongst these blockchains. Solana is far-and-away the most volume of any of the large blockchain projects, and it’s no surprise that it got there by learning to create one of the most efficient and lowest-cost chains:

Ethereum’s growth has been sustained by an orders-of-magnitude drop in transaction-costs.

The decreases in unit-costs that accompany higher volume are a function of the “learning rate.” This is the mathematical expression of how an industry learns to reduce costs, passing along cost reductions to customers through competitive market forces.

Alongside Ethereum’s growth and improvements is the emergence of Layer 2 networks, which help Ethereum scale through interoperating, separate chain architectures. These layer 2’s have had their own learning journey: Arbitrum volume has increased 8x while its average transaction over a period that transaction costs decreased by $0.20 to $0.03 (-38% learning rate) thanks to things like their sequencer upgrade (Nitro).2 Base has had its volume increase 7x while its costs decreased from $0.04 to $0.012 per transaction (-27% learning rate).

Solana supercharges on-chain volume

There’s no large-scale blockchain that exemplifies Wright’s Law more strongly than Solana. By freeing itself to the technological constraints of Ethereum entirely, it created a high-performance, low-cost network where its average transaction fee is 1% of the average of Layer 1’s:3

Solana’s early market lead, low cost and high-TPS has led to it now processing far more transactions than all the other Layer 1’s combined:4

This ecosystem is why many of the top DePIN projects (Beamable, Helium, Render) have chosen to build on Solana. As Solana DePIN projects grow, they’ll in turn drive even greater volume onto Solana—which will result in further learnings to reduce costs.

One example of this learning is Sonic, which is building the first layer 2 for Solana. It’s called Hypergrid, which is for “high-demand applications like games, DeFi, AI Agents” [Sonic docs]. By building a layer 2, these demanding applications can further reduce their already-low Solana transaction costs:

Markets for Internet Servers

Cost curves extend well-beyond blockchain; another great example is the cost of running internet servers. The pioneer in this industry is Amazon, who invented Amazon Web Services to allow other companies to rent Amazon’s massive datacenters to power their own applications. Along with Microsoft Azure, Google Cloud Platform and others, this market today operates from over 1,000 “hyperscale” data centers:

Why did this happen? It turned large hardware investments by individual companies into data centers (CapEx) into pay-as-you (OpEx). The learnings within this industry have been enormous, resulting in order-of-magnitude decreases in unit-costs of compute while driving exponential increases in utilization:

One of the key learnings in cloud is called “serverless” compute. One example of serverless is AWS Lambda, which works like this: you stop renting a whole server by the hour, and instead pay only for the few milliseconds your code is actually running. Behind the scenes AWS keeps a giant pool of machines and loads your function onto one just long enough to finish the task, then frees that space for someone else. Functions that sit idle 99 % of the time on a virtual machine cost 90% less once billed in 100 ms increments. These are the sort of efficiencies that have continued to make cloud computing such a compelling option for customers.

DePIN: The Successor to Cloud

We are on the threshold of the next generation of cloud architecture, called decentralized physical infrastructure networks. DePIN is like Uber, but for computers and other hardware—instead of renting capacity from a central provider like Amazon, you “ride share” on the resources provided by owners on the network.

The mechanics of DePIN will fuel the next generation of cost decreases and expanded utilization:

• Competitive market forces converge costs closer to underlying energy and CapEx usage—effectively turning compute into a new liquid asset class. Hardware & bandwidth costs decline because more nodes across multiple suppliers = market-based pricing, denser resource mesh, better routing, higher utilisation—classic learning-curve mechanics.

• DePIN infrastructure builds upon serverless compute by allowing multi-tenanted nodes to maximize their use of underutilized compute resources.

• Similar to Uber, the network gets more valuable the denser the network is around you—some people will offer a “black car” premium level of service (high-end compute resources), vs. others will drive you in their UberX for lower cost (cheap servers). Applications can optimize their costs around a market of suppliers with varying service levels.

• DePIN accelerates the software development flywheel. As network effects attract third-party builders who compose solutions on top of the DePIN, they attract more customers who like the wide availability of open-source solutions, who attract more third-party builders…

Nearly a hundred years of Wright’s Law has shown that further increases in utilization will happen alongside cost decreases, leading to overall market expansion. As node counts double, expect another ~20-30 % slash in compute / 5G / storage prices—opening markets like more innovative games and simulations, real-time AI inference and edge rendering.

At Beamable, we’ve seen this firsthand in the game industry: innovations in serverless compute have enabled us to efficiently support the backend needs for everything from massive game launches, such as Mythical Games FIFA Rivals—to scrappy startups like RC Games Studio, who were able to ship an online game with 94% positive ratings on Steam with a tiny team.

Beamable Network is the gaming DePIN that builds upon the efficiency of serverless, open ecosystems and the power of Solana. We’re excited to supercharge game development—while opening up a whole new universe of community-owned gaming infrastructure.

Subscribe now

Infrastructure-as-code2 just escaped the landlord, and the crowd became the cloud.3

The mesh needs money

The internet has always run on open protocols—TCP/IP for packets, HTTP for pages, SMTP for mail. Those rails let anyone move information, but they require additional layers to pay for it. Every time we wanted to settle a bill we bolted on credit-card forms, PayPal buttons, and SaaS invoices.

That bolt-on business model results in the same incentive loop I called out in Enshittification and the Future of AI Agents: once a platform owns the entire user funnel, it charges rent and breaks interoperability to keep you inside. And at worst, they discontinue software that was mission-critical for your business.

But today’s software isn’t just two browsers chatting like SMTP or HTTP in the 90s—it’s entire multiplayer games, AI copilots, and data pipelines that swallow petabytes. To hit that scale you need fleets of GPUs, massive storage, and global bandwidth on demand. When payment is baked into the same API that discovers those resources, the formula flips: instead of negotiating with a hyperscaler4 for capacity, any qualified operator on the internet can add capacity and earn as the network spreads. In effect, the internet learns to provision itself.

Composability super-charged

Now a coder can stitch together resources (game servers, AI inference engines, file storage, etc.) with a few contract calls. That’s the missing ingredient that shrinks the jump from idea → live product to a weekend hack, even when the product depends on physical infrastructure.

Protocols with integrated payments aren’t just a nicer checkout—they’re the energy that lets DePIN light up at all: value-exchange, compute infrastructure, and intelligence organizing at the speed of an idea, letting tiny teams launch projects that once demanded venture rounds and data-center contracts.

DePIN is a Software Distribution Framework

Most of the emphasis on DePIN is its obvious power to deliver raw compute and hardware devices. But when you combine scalable hardware infrastructure with the payment rails that are inherent in DePIN, there’s another layer of value-add that some networks are beginning to uncover: they’re software delivery networks.

For example, Beamable Network’s technology roadmap includes features to enable creators to deliver backend solutions through an open marketplace, with on-chain reputation and on-chain licensing/royalties. These services snap together in an interoperable framework, letting game studios build games faster—crowdsourcing many of their complicated problems to developers who get paid for helping out.

DePIN Addresses Web2 Demand

Most crypto projects are targeted at crypto-native users. DePIN is different: the supply-side tend to be crypto-native, but the customers of the network (the “demand-side”) can be anyone. DePIN targets already-established demand that exists outside of web3, yet harnesses web3 to deliver a higher-performing, lower-cost and decentralized alternative.

A good example is Beamable Network, a DePIN for gaming backends. Most of the gaming market—over $200B in consumer revenue, which spends $35B+ per year on backend technology—are Web2 and are going to stay Web2 for quite some time. The Beamable SDK makes it easy to provision and scale-up the game servers needed to run a live game without any knowledge of backends, networking or blockchain.

DePIN Scales Nonlinearly

DePIN can scale nonlinearly when it uses a multi-tenanted architecture—meaning that it allows individual nodes to service the compute needs of multiple applications (as opposed to the long-term leasing model favored by bare metal providers and the hyperscalers).

In other words: DePIN turns physical devices into on-chain services that meter usage by the second or by the byte. A hotspot forwarding two kilobytes, a GPU rendering one frame, a home battery pushing out a surplus watt—each action is tiny, constant, and global. The payment layer has to be as programmable and permissionless as the routing layer.

DePIN is Lower Cost

DePIN effectively turns resources like compute into a liquid asset class—similar to what’s happened with energy trading in the modern power grid. Competitive forces mean that datacenters compete for business based on commoditized hardware provisioning, rather than proprietary APIs and long-term contracts intended to lock you in.

Reverse on-chain auctions and order books clear on a continuous basis, pushing margins toward commodity pricing—just like electricity spot markets.

How much lower? Fluence provisions traditional compute resources at 85% less cost than AWS. And Akash reports savings of 50-70% on the provisioning of GPUs.

The Community-owned Future

The first clouds let anyone rent servers; DePIN lets anyone own the cloud’s upside.

By fusing discovery, metering, and payment into one programmable layer, it invites every router, GPU, and solar panel onto an open marketplace—no procurement team required. For builders, that means shipping products at the speed of code rather than capital; for operators, it turns idle hardware into a global revenue stream.

As these networks stitch themselves together, the line between “user” and “infrastructure provider” blurs—and the next wave of software will run on a mesh that literally pays for itself.

Subscribe now