What Internet of Agents?

The web has had three eras of how a page gets built. In the first, every page was hand-coded HTML — the file you wrote was the file the browser loaded, and a "website" was a stack of static documents linked together. In the second, pages got dynamic: a server stitched together a template and a database query at request time, which is how every login-gated app, every product page, and every news feed has worked for the past twenty years. The structure of the page was still designed by a human, but the contents got assembled fresh on each visit. In the third — the one we're in now — the structure itself starts to move. Headlines get rewritten by a model. Layouts get reordered. Components get swapped in and out. Two visitors loading the same URL can see materially different pages, and the differences are decided not by a CMS rule but by an inference call.

That third era is where most of the energy in web tooling has gone since 2023, and it has produced a strange industry. Vercel's v0 sits at the center of it — over four million users generating React components from prompts, a $9.3B parent company, and a developer ecosystem that already runs much of the modern web. Around that anchor, a wave of newer companies is trying to push the idea further: Coframe (whose "living interfaces" thesis treats every piece of UI as a self-improving asset), Thesys (an OpenAI-compatible API that returns interactive UI instead of text), Lovable and Bolt (full-stack app generators), and a long tail of personalization platforms — all of them describing themselves as generative-web companies, but none of them solving quite the same problem. Some are building tools for designers. Some are building runtime APIs. Some are building bandits on top of generated variants. The shared assumption is only that the page should adapt; the disagreement is about who it should adapt for, when, and through what mechanism.

Pulling that disagreement apart matters because visitor behavior has changed underneath the industry. Users arriving from ChatGPT, Perplexity, Google AI Mode, or Comet have already had the question-answering step happen before they hit a URL — by the time they reach a page, they are verifying, not browsing. And a growing share of visitors aren't human at all: AI-driven traffic to U.S. retail sites has grown by orders of magnitude in the past year. The page has to be the right page for whoever — or whatever — is asking. The technologies that try to make that happen are what this memo calls generative web agents.

The Core Dynamic

The right way to read this space is as a spectrum of how aggressively AI inserts itself into the page-loading process. At one end, AI sits entirely outside the page — humans design and ship the variants, and a model only chooses which one to show a given visitor. In the middle, AI produces the page contents themselves, but inside human-defined constraints — generating copy, swapping components, restructuring layouts within a brand-safety envelope. At the far end, AI replaces the page-loading process altogether — the human never visits a URL, an agent talks to a structured endpoint and the user sees the result inside a chat interface. Each position on this spectrum is a coherent product category with serious capital behind it, and where a team places its bet on this spectrum shapes nearly every downstream architectural decision. Naming the positions clearly is the first useful thing this memo can do.

A bit of vocabulary first, because three terms get used interchangeably in vendor copy and shouldn't be:

• Design time is when a developer is building the website. This happens before any user visits. The output is files saved to disk — HTML, CSS, JavaScript, React components — that get deployed to a server.
• Runtime is when a real visitor's browser actually loads the page. The output is pixels on a screen.
• Render is the act of converting source code into pixels. In a traditional website these phases are sequential and the user only sees the runtime; in the new generative-web tools they get blurred in interesting ways.

A second piece of vocabulary, used heavily below: a multi-armed bandit is a class of algorithm that decides which of several variants to show a given visitor while it's still learning which variant is best. Unlike a classical A/B test, which splits traffic 50/50 until the test ends, a bandit shifts traffic toward whichever variant is winning as it goes — so you "earn" conversions while you "learn" which variant performs. Contextual bandits extend this idea by conditioning the variant choice on per-visitor signals (device, referrer, prior behavior). Bandits are the statistical machinery underneath most modern personalization, and they show up across the spectrum below.

Vision 1: The Page Stays the Same, Bandit Gets Smarter

This is the lightest-touch position on the spectrum. AI sits entirely outside the page-loading process: humans design the variants, ship them through a normal release cycle, and the AI's only job is to decide which pre-built variant a given visitor sees. The bet is that the previous decade's failure mode wasn't that pages were wrong — it was that they were tested too slowly and segmented too coarsely. Modern contextual bandits, properly fed by a customer data platform, can already personalize in real time per visitor without ever generating new content.

This is the entire mature conversion-rate optimization (CRO) industry — Optimizely, Dynamic Yield (acquired by Mastercard), Adobe Target, VWO, AB Tasty, Salesforce Marketing Cloud Personalization, Bloomreach, Monetate. It is also where most of the AI-native CDP layer sits today: Hightouch's AI Decisioning, Contentful Personalization, Insider, Segment-plus-bandit stacks. It is a roughly billion-dollar market growing at a healthy double-digit rate. The architecture is mature: a CDP unifies visitor identity across devices and sessions, segments visitors into archetypes, and a contextual bandit selects which of N pre-validated variants to show. The variants are designed by humans and shipped through a normal release process, so brand fidelity, accessibility, and legal compliance are bounded by human review. The "personalization" is in the selection, not the production.

The strongest argument for this bet is that it already works at scale. The strongest argument against it is that the variant set is bounded by what a team had time to ship — and once a generative system can produce a new variant in seconds, the bandit has more arms to pull than any human-built variant set could ever provide. Whether generation gets absorbed into the existing CRO stack (Optimizely shipping generative variants on top of its bandit) or whether a generative-native vendor displaces the incumbents is one of the live contests in this space.

Vision 2: The Page Regenerates Itself Per Visitor

This is a much heavier touch. AI moves inside the page-loading process and produces the contents itself — copy, layout, hero imagery, component arrangement, CTA hierarchy — conditioned on who is visiting. The page still exists and the visitor still sees a coherent designed surface, but the work that used to take a designer plus an engineer plus a PM plus a two-week sprint can now happen in seconds, and because it can happen in seconds, it can happen per visitor.

Vercel v0 is the most-used product in this category, and it shows the design-time end of the spectrum. v0 is a tool a human developer or marketer uses to build pages in the first place — generation that happens before any visitor arrives, with the model as a faster designer rather than a runtime renderer. The new v0, launched in February 2026, evolved from a component generator into something closer to a full-stack development environment: it can import any GitHub repo, pull in environment variables from Vercel, open pull requests against main, and let non-engineers ship production code through proper git workflows. Vercel's framing is "we lowered the barrier to writing code; now we're raising the bar for shipping it." v0 answers the "different web for every visitor" prompt only indirectly — it lets a marketing team ship five landing pages instead of one, which lets a downstream personalization layer route visitors to whichever page fits.

Coframe pushes further. Where v0 generates pages developers ship and forget, Coframe runs a continuous loop in the background of someone else's website, generating new variants and routing visitors to them via a multi-armed bandit. Josh Payne, founder of Coframe, argues that "every piece of copy out there and every piece of UI should have a KPI that is actively optimizing itself for that specific person who is on it." Coframe's October 2024 partnership with OpenAI's vision fine-tuning team was specifically about closing the brand-fidelity gap that off-the-shelf vision-language models have. Coframe trained a custom GPT-4o variant on a large collection of websites and built BrandBench — a 194-website LLM-as-judge benchmark for visually-grounded UI generation — and reported a 26% improvement on BrandBench over GPT-4o base. The point of the partnership wasn't to build a better LLM in general; it was to make generated UI look enough like a real brand's existing site that growth teams could ship it.

Thesys pushes furthest, all the way to per-request runtime generation. Thesys's product, C1, is an OpenAI-compatible API endpoint that returns interactive UI components — forms, tables, charts, dashboards, multi-step flows — instead of text. The pitch in their docs is direct: "Generative UI is a paradigm shift where AI dynamically generates the user interface itself." A developer points their existing OpenAI client at api.thesys.dev and replaces their markdown renderer with a C1Component, and now every model response is a freshly generated React tree streamed into the browser as it's produced. The model is on the critical path of every render. Two different users asking different questions of the same app see different UIs in the same response window. Lovable and Bolt sit alongside as full-app generators — closer to v0 in being design-time tools, but generating entire applications (frontend, backend, database, auth, deployment) from a description rather than just components.

These products span the entire generative half of the spectrum but share an underlying bet: the surplus value will go to whoever owns the generation of the surface, not the bandit selecting from it. v0 bets on developer-time generation, Coframe bets on continuous generation behind an existing site, Thesys bets on real-time per-request generation. They disagree about latency budgets and product surface area, but they agree that AI's job is to produce the page, not just to choose among versions of it.

An Aside on Agent Traffic

Agent traffic doesn't replace the human page, but it does add a second audience that needs to be served.

The far end of the spectrum — AI replacing the page-loading process entirely — shows up in a lot of strategy decks as if it were a competing vision, but it is better understood as a separate axis. The pattern is the agentic commerce stack — OpenAI and Stripe's Agentic Commerce Protocol (ACP, live in ChatGPT since September 2025), Google's Universal Commerce Protocol (UCP, announced January 2026 with Walmart, Target, Shopify, and 20+ partners), Visa's Trusted Agent Protocol, Shopify's Agentic Storefronts, Mastercard's Agent Pay. The pattern's premise is that for some traffic — high-intent purchases especially — the agent talks to a structured endpoint and the user sees the result inside ChatGPT, Gemini, or Comet. The page never renders. The behavioral data is striking: a meaningful share of referral traffic to large retailers now originates from AI assistants, and agent-mediated retail spending is on track to multiply many times over in the next twelve months.

Agent traffic creates a second audience with different needs, and a site that ignores it will become invisible to a fast-growing channel. Webhook-style structured endpoints, llms.txt files, MCP servers, ACP-compliant product feeds — these are the agent-side complement to whatever the human-facing page does, not a substitute for it. The cleanest way to think about the implication for a generative web agent is this: the same content graph now needs to render as both a designed page (for the human) and a structured endpoint (for the agent), and the consistency between those two surfaces is itself a product.

Three Theses

Thesis 1: The unit of personalization is shifting to "the answer.”

The most-discussed version of this shift — that the page itself dies and a conversational interface replaces it — overstates the change. What's actually changing is not the page as a form factor; it's the page as the first thing a visitor encounters in a session.

Users coming from ChatGPT, Perplexity, Google AI Mode, or Comet have already had the question-answering step happen before they hit your URL. By the time they arrive on a page, they are not browsing — they are verifying a recommendation an AI already made. The page is no longer the place where the user forms intent; it's the place where they confirm or reject it. 

For a generative web agent, this changes the design brief in a specific way. The page no longer needs to do the work of attention capture, value-proposition explanation, and trust-building from scratch — because the agent that sent the visitor already did most of that work. The page needs to do the next job: deepening the specific intent the agent has already formed. A visitor whose AI assistant said "this looks like the cheapest option" needs a page that defends the price. A visitor whose assistant said "this brand has the best reviews" needs a page that surfaces the reviews immediately. This is a much harder problem than to simply show different hero copies to users from different referrers, because the agent's internal reasoning isn't passed in the URL. The page has to infer it.

The architectural consequence is a brand's competitive moat is no longer the page it ships; it's the content graph the page is rendered from, the freshness of that graph, the breadth of facts it expresses, and the cleanliness of the relationships between them. The team building a generative web agent should assume that the same underlying graph will be rendered as a marketing page, a structured product feed for ACP, and an MCP-compatible endpoint for any agent that asks — sometimes within the same session, for the same visitor.

Thesis 2: The defensible product is the constraint layer, not generation.

The generative-UI camp is right that pages will be generated, and probably wrong about who captures the value. The model providers (OpenAI, Anthropic, Google) and the design-system providers (Vercel, Thesys, Figma, Builder) are racing to commodify generation itself. The marginal cost of generating a plausible page is collapsing, which means the surplus is unlikely to live in the generator.

What stays scarce is the layer that decides what the agent is allowed to generate, and for whom, under what conditions. This is the part that doesn't ship in an SDK. A brand's design system, voice guidelines, regulatory disclaimers, accessibility floor, legal review process, and pricing constraints are all deployment-specific. None of them live in the model, nor are any of them obvious from the rendered page alone. A startup that ships "we generate UIs from prompts" is selling commodity. A startup that ships "we encode your brand's complete constraint surface and make it queryable by any generative system" is selling something different.

Coframe's BrandBench is the cleanest expression of why this matters. The whole reason the company partnered with OpenAI to fine-tune a custom GPT-4o variant was that off-the-shelf vision-language models can produce highly opinionated UI given a design system, but had limited ability to faithfully pick up on existing aesthetics and brand design. Visual grounding for brand-specific UI generation isn't in the base model — it has to be encoded somewhere, and that encoding is the product. The HaystacksAI acquisition extends the same pattern into intent inference: the more deployment-specific context the system encodes, the harder the generator is to disintermediate.

The architectural consequence is the proposer/validator split, which is becoming visible across the serious products in this space. The proposer is cheap, fast, frequently wrong, and increasingly a vendor relationship — Claude, GPT-5, Gemini, an open-source local model. The validator is slow, expensive to build, deeply company-specific, and where the moat lives. It encodes brand, runs accessibility checks, applies regulatory filters, gates against the bandit's confidence threshold, and optionally routes to a human reviewer. Coframe's autopilot vs. copilot mode framing is the productized version of this split.

Thesis 3: The page is unbundling into two surfaces.

The agent traffic aside above is structural enough to deserve a thesis-level treatment. The page is not being replaced, but it is being unbundled: the same product, the same brand, the same content graph now needs to render as a designed surface for humans and as a structured endpoint for agents — and the two surfaces increasingly answer to different optimization functions.

The numbers on the agent side are no longer speculative, as retail spending mediated by AI platforms is projected to roughly quadruple in 2026 over 2025. The protocol layer is no longer hypothetical — ACP is live in ChatGPT, UCP launched with Walmart and Target as anchor partners, MCP servers are now table stakes, and Visa's Intelligent Commerce platform has signed up partners across the merchant, payments, and agent stacks.

Coframe sits on the human side of this unbundling, and the question for a generative-web agent built on a Coframe-style foundation is how it extends to the agent side. The three plausible architectures, none of them yet fully built out by anyone:

(a) Render the structured endpoint as a side-effect of generating the page. Every variant the system generates also produces a Schema.org / MCP / ACP-compatible representation, so the agent and the human are guaranteed to see consistent content. This is the cleanest architecture but the hardest engineering.

(b) Treat the structured endpoint as the source of truth, and generate the page from the endpoint at render time. The content graph is canonical, and both surfaces (rendered page, agent answer) are derived. This pattern matches better with how mature CMSes already work, but it inverts the bandit logic — you're optimizing the structured representation, not the rendered surface.

(c) Build the two surfaces independently and reconcile them in QA. Most teams shipping today are quietly here, because it's the only architecture that ships in a quarter. It's also the architecture that produces the highest content-integrity failure rate, which is the failure mode that compounds fastest as agent traffic grows.

The teams that get this thesis right will probably ship a version of (a) or (b) packaged as if it were (c) — a system that lets a growth team operate as if they're just personalizing the human-facing page, while quietly generating and reconciling the agent-facing surface from the same primitives. That's a real product, but arguably most of the offerings in market are not yet that product.

The Market Map

The space has three distinct stacks worth tracking, and most market maps in circulation cover only one of them. The map below combines what Rye's March 2026 agentic commerce landscape, Gartner's 2026 Magic Quadrant for Personalization Engines, the CopilotKit/A2UI ecosystem documentation, and our own research. It is organized as three layers — generative web (where the page itself becomes adaptive), personalization and CRO (the mature industry being disrupted), and the agentic web (the protocol layer for agent traffic) — because those layers correspond to the three theses above.

Layer 1: Generative Web

These are tools that produce the page itself.

‍

Layer 2: Personalization & CRO

This maps the existing industry that is being disrupted.

‍

Layer 3: The Agentic Web

This includes protocols and infrastructure for agentic traffic.

‍

What We're Watching

The memo's core argument is that the generative web agent space is a multi-bet contest, that no single vision wins outright in the next twelve months, and that the most defensible startups will be the ones that pick a sharp position on at least two of them. Constraint, content-as-graph, and dual-surface architecture are the three axes where positioning accrues. Here are the signals we would watch to confirm or falsify that read.

Whether ACP, UCP, and the broader MCP ecosystem consolidate or diverge. Right now there are several serious agentic-web protocols with overlapping but non-identical scope. If the next twelve months produce convergence — most likely under the MCP umbrella, with ACP/UCP slotting in as the transaction layer — then the agent-facing surface becomes a single integration target and the unbundling thesis hardens. If the protocols stay fragmented, every site has to ship N integrations, which favors the platform-level vendors (Shopify, Salesforce Commerce, Adobe) over startups.

Whether a generative-web vendor ships a credible dual-surface product. Coframe today is a Vision 2 product with the option to extend toward the agent-traffic side. v0 and Lovable today are Vision 2 products that have not yet shown they can extend at all. If a vendor in this space ships a "your content graph renders as both a human page and an agent endpoint, from one source of truth" product in the next twelve months and gets enterprise traction, Thesis 3 hardens fast and the rest of the category has to catch up. If no one ships it, the dual-surface architecture stays a theoretical concern and the bandit-on-pre-generated-variants approach keeps winning on shippability.

The trajectory of v0, Lovable, and Bolt downward into runtime personalization. Right now those tools are positioned as "generate the site," not "personalize the rendered site for each visitor." The new v0's sandbox-based runtime, Git panel, and direct database integrations push them closer to the runtime side, but they're still fundamentally design-time tools. If they expand into runtime personalization, the question is whether the same generation primitives that produce a static site can be retrofitted into a per-user render loop. If they can, Thesis 2's separation between "model provider" and "deployment surface" softens. If they can't — if runtime personalization requires a fundamentally different architecture — the dedicated category survives and Coframe's bet is correctly priced.

Whether the bandit camp absorbs generation or generation displaces the bandit camp. Optimizely, Hightouch, Contentful, and Dynamic Yield are already shipping generative variants on top of their existing experimentation infrastructure. If their incumbency wins — if growth teams adopt "Optimizely with generative variants" rather than "Coframe with experimentation" — then generation is a feature, not a category, and the dedicated startups have a much harder fight. If a generative-native vendor displaces the incumbents on enterprise CRO, the opposite is true. The early evidence is mixed: Coframe is reporting over 100% quarter-over-quarter growth and over $150M in incremental revenue for customers including Dropbox, but the incumbents have orders of magnitude more deployed surface to defend.

Whether the cost of render-time generation crosses the floor. The single biggest architectural fork in this space is whether you can afford to put a frontier model on the critical path of a page load. Today, mostly no — which is why Coframe runs the model in a background loop and Thesys is mostly used inside AI-native chat applications rather than on traditional marketing pages. If a small model (4B–8B parameters) gets within striking distance of frontier on the variant-generation task, and if edge inference gets cheap enough, the proposer-cheap / validator-cloud architecture starts giving way to fully-edge generation. If not, the cost gravity keeps generation in the warehouse and bandit-style selection on the edge — which structurally favors the incumbents.

See you Saturday.