I was at a meetup with some friends the other day talking about AI search and the future of the internet. As we talked about how we are using our Hermes agents in different ways, we started joking that someone should make virtual meetups for agents. Then we did a hard double-take, because that’s not a joke. That will actually be a thing someday and probably sooner than we are ready to think about.

There’s a Zen Buddhist proverb that’s been on my mind ever since: 我逢人. Gahoujin. It translates simply as “I meet someone,” but the deeper teaching is that every encounter is formative, the quality of your relationships is the quality of your life. Eight hundred years ago, Zen monks understood something enterprise AI architects are only just beginning to grapple with: that the best outcomes don’t emerge from isolation. They emerge from interaction.

We are entering the era where this is as true for agents as it is for people. From ‘who you know is what you know’ to ‘you are who you meet’.

The Three Horizons of AI Experience

In my last post, I argued that the model is not the moat, the feedback architecture around it is. Agent harness” is shaping up to be the phrase of 2026, and the leaders I talk to: heads of product, CTO-1s, and digital experience owners, are already asking the next question. Not “how do we get agents to work?” but “how do we get agents to work with each other?” Across vendors, across platforms, across the boundaries of the enterprise itself.

We are living through three distinct horizons of disruption, and most of the enterprise world is still building for the second one while the third is already forming.

Horizon 1 is conversational search: the “Chat” era. Human asks, agent responds. This is where ChatGPT, Gemini, and every enterprise chatbot lives. It’s mature. It’s being commoditized.

Horizon 2 is conversation experience: the “Orchestration” era. LLMs are becoming the front end to digital experiences. gents connect to tools, execute workflows, operate on your behalf to bring the experience into the conversation box. This is where most enterprise AI investment is going right now. Agent builders, workflow automation, orchestration layers: all H2.

Horizon 3 is what’s next. Agent-to-agent, as in coordination between autonomous systems at machine speed. An H3 world is one where your marketing agent negotiates pricing directly with a publisher’s agent, your procurement agent coordinates with a supplier’s logistics agent, and your security agent is monitoring the integrity of every one of those conversations in real time, all before a human even wakes up. The “Economic Coordination” era.

Horizon 3 is a new paradigm for how intelligence transacts.

The Protocol Shift for Autonomous Agents

Here’s the thing about APIs: they are rigid contracts. You call an endpoint, you pass parameters, you get a response. That’s function calling. It works. It scales. And it is absolutely nothing like the way intelligent systems will eventually talk to each other.

Agent negotiation in Horizon 3 will be economic. When your agent needs to procure a capability from another agent, like processing capacity, a data enrichment, or a content decision, the negotiation involves cost, risk, quality tradeoffs, and time horizons. That’s not a function call. That’s a market transaction. The “reward” in that interaction is no longer just “task completed.” It’s optimal outcome, at managed risk, within acceptable latency. The reward signal evolves.

Swyx at Latent.Space has been mapping this architecture carefully, and what he describes as a “harness of harnesses”, orchestrating agent swarms that manage orchestrated agent swarms, is a reasonable picture of where the infrastructure is heading. We are moving from one agent with a toolbox to networks of specialized agents with reputations, negotiating workflows in real time.

Which brings us straight back to 我逢人. You are who your agents meet.

The Missing Layer: Why Your Agents Can’t Negotiate (today)

Before agents can negotiate with each other, they need to speak the same language. Not English; an ontology. A shared semantic model of what your enterprise knows, what it values, and how it makes decisions.

Right now, most enterprise agents rent their logic from the underlying model. They don’t own a durable representation of the organization’s intent. This is why production failures in agentic systems are almost never model failures; they’re architectural gaps. The agent does exactly what the model thinks it should do, in the absence of the organizational context that would make that decision actually correct.

Vin Vashishta frames the downstream consequence well: organizations that can’t articulate their decision logic to their agents will keep paying consultants to patch failures that are actually structural. You can’t govern what isn’t legible.

The AI Realized Now team has been precise about the specific infrastructure gap: what agents need isn’t just data about outcomes: it’s decision traces, as in the reasoning that produced the outcome. Why was this discount approved? Why was this customer escalated? Why did the agent override the default policy? That reasoning lives in emails, Slack threads, and meeting notes, or in nobody’s system at all. Context graphs, graph-based records of decision lineage, are the layer that makes that reasoning queryable. Without them, agent-agent negotiation has nothing to stand on. One agent can’t verify another agent’s judgment call if neither agent has a record of why it made that call.

The ontology is the map. Without it, your agents aren’t navigating. They’re guessing.

Reputation Is the New PageRank

Here’s the Web 2.0 parallel that I keep coming back to, because I think it’s exactly right.

Google organized the world’s information using links as votes. PageRank worked because it was a proxy for trust: if authoritative pages linked to you, you were probably worth reading. The social graph that defined Web 2.0 compounded on the same principle. Who followed you, retweeted you, vouched for you was your reputation made legible to the network.

In the agent web, the equivalent signal is verifiable execution history. Did your agent deliver the promised outcome? Under what conditions? What exceptions did it approve, and can it show its reasoning? That decision lineage, auditable, queryable, and persistent, is the reputation score that will determine whether another organization’s agent agrees to work with yours.

The moat in this world is not the model. It’s not even the data. It’s the network of trusted agent relationships your organization has built, and the reputation those agents have earned through consistent, verifiable performance.

This is where the security question lands, too. Kris Kimmerle has been mapping the emerging attack surfaces in agentic architectures, and the pattern is clear: agent-to-agent communication is the new perimeter. Identity, permissioning, and trust between machines is now a first-class security problem, not an afterthought. If your agent is negotiating with my agent, both of us need to know that the agent on the other side is who it claims to be, has the authority it claims to have, and is operating within the constraints the human principals actually set.

Reputation without verifiability is just vibes. And vibes don’t scale.

What This Means If You’re Building

Own your ontology before you scale your agent mesh. If your agents don’t have a durable, shared semantic model of how your organization makes decisions, they can’t negotiate on your behalf, they can only execute tasks inside the boundaries you’ve hard-coded. The companies building internal knowledge graphs and decision trace infrastructure now are building the negotiating table for H3. Everyone else is bringing agents to a table they didn’t build and don’t control.

Architect for agent reputation from day one. Every decision your agents make is either an asset or a liability in the reputation economy that’s forming. Decision traces, audit logs, outcome attestations: these aren’t compliance overhead. They’re the currency your agents will use to earn trust from other systems. Build the logging infrastructure like it’s the product, because in H3, it is.

Governance has to scale with the mesh. Single-agent quality controls like review queues, human-in-the-loop checkpoints, and policy guardrails, were designed for H2. The H3 governance challenge is cross-agent outcome verification at network scale. The new control framework, where you set business-outcome setpoints, measure against them continuously, and adjust policy dynamically applies here, but it needs to operate across agent boundaries, not just inside a single workflow. Start designing the governance layer now, before the mesh scales past the point where you can see it.

What the Next 12–18 Months Look Like

The infrastructure conversation is going to shift fast. Right now the question is “how do I build agents?” By end of 2027, the question will be “who do my agents trust, and why?” The companies that will define that answer are already building the protocol layers: the agent registries, the capability marketplaces, and the reputation ledgers that will become the connective tissue of the agent economy. The model race will matter less than the network race. Google organized information. The next platform organizes capabilities.

There’s a test I’d encourage you to run this week. Ask your team: when one of our agents makes a consequential decision, where does the reasoning live? Is it queryable? Is it auditable? Could another system verify it? If the answer is “it lives in the model’s context window and then it’s gone”, you’re building for H2 in a world that’s moving to H3.

The Zen masters understood that who you encounter shapes what you become. Your agents are already meeting the world. The question is whether those meetings are building something like a reputation, a network, a compounding advantage, or disappearing into the noise.

By now we’ve probably all heard the term “metaverse.” Facebook renamed itself Meta to grab mindshare and marketshare before virtual worlds reached mass adoption. The term came from decades earlier, in the cyberpunk classics of the 1980s and 90s, Neuromancer, and my favorite, Snow Crash. In Snow Crash, the most prestigious job left in a collapsed, privatized America is pizza delivery specialist, the “Deliverator.” Thirty minutes or less guaranteed, under pain of death if you’re late. The same joke is funnier in 2026 than it was in 1992, because we’re not reading about a fictional collapse of knowledge work anymore. We’re watching agents take over the actual knowledge work, in real product launches, in real enterprise releases, this month.

When Hiro Protagonist of Snow Crash isn’t delivering pizzas, he’s plugged into the Metaverse, a fully-realized 3D digital world where his avatar is a sword-fighting legend. Ready Player One tapped the same idea two decades later with the OASIS. Both versions share one assumption: the Metaverse is a place you visit. What’s becoming real in 2026 is stranger and more useful: a parallel world of digital experience that isn’t visited at all, it’s consumed and acted on by agents, continuously, while you’re doing something else entirely.

Decisions Used to Be Discrete Events

The week of June 15, 2026 is when a lot of us started using a new term for this: decision gravity. Alex Dean at Source of Truth coined it while unpacking Databricks’ CustomerLake launch, framing it as the successor to data gravity, the old battle over where your data physically lived. Decision gravity is about something more consequential: who, or what, actually makes the call. Data gravity was won by the platforms. Decision gravity is being won, right now, by whoever builds the layer that agents to guide their optimization loops.

For twenty years, enterprise software has been built around the assumption that a decision is something a person makes at a moment in time. You approve the campaign. You ship the release. You sign off on the budget. The software’s job was to present options and record the choice. Even “automation” mostly meant automating the steps between decisions, not the decision itself.

That assumption is what’s breaking right now, and it’s breaking from two directions at once: the application layer and the infrastructure layer.

What’s Changing: The Application Layer Already Moved

Start with Databricks’ CustomerLake, announced this week. It doesn’t add AI to the customer data platform category, it rebuilds the category around the idea that a “campaign” is no longer a thing a marketer launches and reviews. CustomerLake runs what Databricks calls infinity campaigns: continuous, always-on personalization driven by Profile Agents and Campaign Agents, with no human-authored brief in the loop. Optimizely shipped something parallel in mid-June with Limitless 1:1 Personalization, true individual microsites built, governed, and continuously optimized by a chain of agents, audit, audience intelligence, generation, progressive trust, publish, optimize, with no marketer approving any single variant.

Notice what’s actually being delegated here. It isn’t the execution. Marketing teams delegated execution years ago. It’s the moment-to-moment judgment call about what’s working and what to try next. That’s decision gravity moving from a person reviewing a dashboard to a system that’s already acting on what the dashboard would have shown.

What’s Changing: The Infrastructure Layer Just Caught Up

If the application layer is where decision gravity becomes visible, the infrastructure layer is where it gets engineered. Databricks open-sourced Omnigent the same week, a meta-harness that sits above Claude Code, Codex, and your custom agents, making them composable and governable the way Kubernetes governs servers. Matei Zaharia and team put it plainly in the launch post: the models and harnesses will keep changing as the field evolves, the layer you work at shouldn’t have to. Joe Toppe called it the right bet, pointing out that most enterprises are already running three to five agent harnesses with no shared control plane and no clean way to swap one out. Read the control model closely and it’s not really about combining agents, it’s about deciding in advance what an agent is allowed to decide on its own. Their example: after this agent downloads a package, require human approval before any git push. That’s a pre-committed reward boundary, encoded as policy instead of as a person checking a box.

NVIDIA’s Secure Agent Workspace Reference Design, also published this June, makes the same bet from the security side. Its core argument: the endpoint where a human interacts with an agent is a presentation layer, not an execution layer, the agent should run in a managed, policy-bounded environment, governed by a signed delegation record that defines exactly what it may do right now. Toppe’s read on the same design is the line worth sitting with: the agent is not the risk, the environment is. Put those two releases together and the pattern snaps into focus. The biggest infrastructure players in AI aren’t racing to make agents smarter, they’re racing to build the layer that decides, structurally, which decisions an agent gets to make alone. That’s decision gravity, encoded directly into the platform.

Welcome to the AgentVerse

Put the application layer and the infrastructure layer together and you get something bigger than a product trend. We’re entering a parallel layer of digital experience, call it the AgentVerse, where the campaigns, the content, the customer interactions, even the knowledge graphs that describe what an enterprise knows about itself, are now generated and acted on continuously by agents, with humans setting intent rather than executing tasks. It’s not a place you log into like the Metaverse that Neal Stephenson imagined in Snow Crash. It’s the operating layer underneath the digital experiences you already use, running whether or not anyone’s watching it in the moment.

Three years before any of this had a name, Dmitry Shapiro sketched the individual-scale version of the exact same architecture. His concept, a Digital Mental Model, was a continuously-updated profile built from datapoints, your preferences, your blind spots, your taste, accumulated one interaction at a time. The point wasn’t to describe you. It was to give a Personal Digital Agent something to optimize against, so it could act on your behalf instead of waiting for you to act.

Swap “you” for “a marketing ecosystem” and you’ve just described CustomerLake’s agents. A human being and a market are the same kind of object to a reward-seeking system: preferences that aren’t known in advance, only inferred from behavior and refined every time the system acts and observes the result. That’s not a metaphor, it’s the same reinforcement learning loop running at two scales. The AgentVerse isn’t just agents acting on enterprise data. It’s reward-seeking systems on both sides of every transaction, each one modeling the other. Individuals are organisms an agent learns to serve. So, it turns out, is a marketing organization.

And the AgentVerse needs a map the same way the physical world needs roads. That’s what Databricks’ Genie Ontology is actually for, a living context graph of the enterprise that agents reason over, with PageRank-style authority ranking deciding what counts as a trustworthy source. Vin Vashishta made the sharpest version of this argument back in April, writing that the knowledge graph is the operating system agents run on, and that if agentic platforms aren’t architected to align with the business, they will disrupt it. Information is the new code, in his words. I’d push that one step further: in the AgentVerse, the reward signal is the new governance.

What This Means If You’re Building

Two takeaways, whether you’re building agents or buying them.

Make the reward signal your system is optimizing for a structured record, not a vibe. In my last post, I argued the constraint on AI systems isn’t model capability, it’s the reward signal. The teams at AI Realized Now have already named the artifact that signal lives in: a decision trace, a structured record of the inputs gathered, the policy evaluated, the exception invoked, the approval collected, and the outcome later observed. Both releases above are, underneath the branding, decision trace systems. They capture not just what an agent did, but what it was allowed to do and why, at the moment it did it. If your agents aren’t producing that record today, you don’t have a reward signal, you have a guess you’re hoping holds up in an audit.

Treat policy boundaries as part of the product, not a security afterthought. Omnigent’s contextual approval gates and NVIDIA’s delegation records do the same job: encoding, in advance, exactly which decisions stay human and which get delegated. If you’re deploying agents without that boundary explicitly defined, you’re not avoiding the decision, you’re just letting the default settings make it for you.

Twelve to eighteen months out, I don’t think we’ll be talking about “deploying agents” any more than we talk about deploying a website today. It’ll just be how the system runs, continuously, with the reward signal as the only lever a human still pulls directly.

So here’s the test I’d apply to anything you’re building or buying in the AgentVerse: can you state, in one sentence, what this system is optimizing for, and can you point to the boundary that stops it from optimizing too far? Answer yes to both and you’re not just deploying an agent. You’re governing one. But it still can’t deliver your pizza.

Like most basketball fans, I turned off Game 4 of the NBA Finals when the Spurs went up by 30 in the 3rd quarter, then tuned back in to watch the last minute on the edge of my seat as the Knicks pulled off an epic comeback win to go up 3-1 in the Finals. And what strikes me about the Knicks is their system: the roster construction, the rotations, the thousands of small adjustments that compound across a season. Talent gets you to the playoffs. Systems win championships.

The same thing is happening in AI right now. The launch of Anthropic’s Fable model is genuinely incredible and every frontier release raises the ceiling on what a single model can do. But that’s not the question I hear from business leaders anymore. The question I hear is: how do I make AI systems reliable, repeatable, manageable, and successful in production? Not “which star do I sign,” but “what system do I build around it.”

In this article I want to address that question through a specific lens: experimentation. As in, optimization and personalization of digital experiences like websites and mobile apps. Because experimentation is transforming from a tool that teams use into the feedback loop that agentic AI runs on.

Where Experimentation Is Today: Bottlenecked by Human Interpretation

The classic experimentation model is linear and human-gated. Hypothesis, variant, traffic, wait, interpret, decide, repeat. Each step requires a person, which puts a hard ceiling on velocity. Most teams run somewhere between ten and twenty experiments a quarter.

Here’s the thing: the bottleneck was never statistical power or traffic. It’s human interpretation latency. Every result sits in a dashboard until someone reads it, contextualizes it, and decides the next move. And the most valuable artifact of the whole process, the record of what was decided, why, and what happened next, lives in emails, powerpoint decks, Slack threads and meeting notes. Unstructured, unqueryable, and effectively lost to the organization.

That model is about to break, because agents don’t operate at human cadence. Kris Kimmerle frames the mismatch well: a human knowledge worker takes maybe fifty meaningful actions a day; an agent takes thousands. You cannot put a human approval gate in front of every one of them. And you can’t simply remove the gates either. Vin Vashishta has written candidly about giving an early agent control of his content operation and watching it destroy performance, because it had no infrastructure for learning what actually worked. Both failure modes point at the same missing layer.

What’s Changing: The Loop Is Closing

Two threads are converging.

The first is warehouse-native experimentation. Platforms like Optimizely Analytics, Databricks, and GrowthBook now evaluate experiments directly against the data in your warehouse, like revenue, retention, customer and lifetime value, rather than proxy metrics like clicks and dwell time. The experiment is finally connected to the outcome the business actually cares about.

The second is agent architectures. Agents now have tool use, planning, and memory. An agent can generate a hypothesis, create the variant via API, route traffic, wait for the warehouse to report the outcome, and record what happened, end to end.

Put those together and experimentation stops being a quarterly team activity and becomes a “primitive” of an agentic system, in other words, a native capabilities. Every agent decision, every piece of generated content, every personalization choice, every routing call, is fundamentally a hypothesis about what works. If the system can’t test that hypothesis against a real outcome and feed the result back, it isn’t agentic. It’s just prompting with extra steps.

That’s what I mean by primitive: not a tool teams use, but infrastructure the agent action layer runs on. And the reward connection is that now, by running personalization and experimentation workflows through agentic systems, you create the foundation of a self-learning for digital experience channels.

Decision Traces: Decisions Are Data

For this to work, the system needs a data structure most organizations don’t have yet. The team at AI Realized Now calls it a decision trace: a structured record of how context turned into action. The inputs gathered, the policies evaluated, the exceptions invoked, the approvals collected, the changes committed — and the outcome later observed.

Read that list again and notice something: an experiment is a decision trace. A hypothesis, a variant, an audience, a pre-committed success metric, and a measured result. Experimentation teams have been producing this artifact for twenty years. What’s new is treating it as first-class enterprise data — durable, queryable, and connected — rather than a screenshot in a readout deck.

This isn’t a vector database, and it isn’t chat history. It’s an architectural commitment: decisions and their lineage become part of the organization’s data model, the same way customer records did a generation ago.

The Reward Signal, Revisited

In my last post, I argued that the key constraint on AI systems isn’t model capability — it’s the reward signal. LLMs are stateless and locally optimizing. They have no persistent representation of whether they’re moving toward the goal. The signal has to come from outside the model.

Warehouse-native experimentation is that signal. Every closed experiment encodes which variant, for which audience, in which context, produced which real business outcome. When the agent learns “urgency-framed headlines for this segment lift revenue per session 23%,” that’s not a heuristic anymore. That’s a gradient — a direction the system can actually optimize along.

This isn’t a theoretical claim. The evidence has been hiding in plain sight for a decade. Microsoft’s experimentation team famously discovered that a simple change to how Bing displayed ad headlines — an idea an engineer had sitting in the backlog — was worth over $100 million a year, a result no executive predicted. Booking.com built its market position running more than 1,000 concurrent experiments, shipping every product change as a test. And in the AI era, the pattern is accelerating: Cursor grew from $4M to $2B in ARR in under two years, not because its model was better, but because every user interaction became a signal that made the next suggestion smarter. The lesson across all three is the same. The model matters. The feedback architecture around it matters more..

Governance: The Hypothesis Library, Augmented for the Age of AI

Anyone who ran a mature experimentation program a decade ago will remember the hypothesis library: a living document where teams accumulated learnings so the next test built on the last one instead of starting from zero. The discipline was always right. What’s changed is the consumer.

When the decision trace history is structured and queryable, the hypothesis library stops being a document humans consult and becomes the memory agents reason over to determine what to test next. Experiment N’s outcome shapes experiment N+1’s hypothesis, automatically. That’s experiment chaining, and it’s where the compounding happens, because every trace makes the next decision smarter.

It’s also exactly where governance becomes non-negotiable. ServiceNow’s research team documented what they call dynamics blindness: frontier models consistently fail to predict the cascading side effects of their own actions. An agent chaining experiments at machine speed without guardrails doesn’t just make one mistake, it compounds mistakes at the same rate it would compound learnings. The governance layer needs to be engineered like a control system: which metrics agents can optimize, which systems they can touch, what budget each experiment chain can consume, and when a trajectory drifting off course triggers human escalation. Continuous correction, not periodic review.

What This Means If You’re Building

Three takeaways, whether you’re building products or platforms:

Treat decision traces as data structures. Audit how your organization records decisions today. If the answer is “Slack and slide decks,” you’re discarding the most valuable training data your agents will ever have. Every experiment, every campaign decision, every exception should produce a structured, queryable record.

Define reward signals on outcomes, not proxies. Connect your experimentation layer to the warehouse, and pre-commit the success metric before anything ships. An agent optimizing click-through will find clicks. An agent optimizing retention will find customers. You get the behavior you measure.

Write governance rules for experiment chaining before you scale. The hypothesis library mindset, made executable: define what agents may test, how learnings carry forward, and where the human stays in the loop. The teams that engineer this layer first will run thousands of safe experiments a day while everyone else is still scheduling readout meetings.

Twelve to eighteen months from now, I don’t think we’ll talk about “running experiments” any more than we talk about “running queries.” It will just be how the system learns. The organizations that win won’t be the ones with the best model, they’ll be the ones whose systems capture the most learning per decision.

So here’s the test I’d apply to any agentic system, whether you’re building it or buying it: does every decision leave a trace, and does every trace make the next decision smarter? Answer yes to both, and you’re building a learning system, one that compounds into a real moat. That’s how systems win championships. 🏆💎

This is an ongoing conversation. I’d love to hear how you’re closing the loop in the comments.

At Google I/O this week, the company unveiled a complete overhaul of the search experience. Welcome to the world of agentic commerce: the entire purchase journey is now contained in the search box. What used to be (before AI mode) a back-and-forth process of queries and responses like a game of ping pong is now a completely conversational and fully functional experience. Before AI mode, the iteration of multiple queries was a process of discovery. You gradually came to understand what you wanted through exploration and refinement. Now, the agent in the search box does the wandering for you. Google’s new Universal Cart lets you add products while browsing Search, chatting with Gemini, watching YouTube, or reading Gmail. And the moment you add something, it gets to work in the background finding deals, tracking price drops, and alerting you when something is back in stock. It incorporates your personalized preferences from past searches and queries. It also includes Agent Payments Protocol (AP2) so you can set guardrails and the agent only pulls the trigger when your criteria are met. The search bar isn’t the start of the journey anymore. It’s the whole journey; and search is an autonomous agentic process.

This is an inflection in an arc of transformation that’s been building over the past few years; and things are about to get faster.

The Three Horizons

Last year, I wrote a piece called The Role of Websites in the Age of AI. At that time, my core provocation was that it took 3x more content on your site to get a visit from Google than it did 10 years ago, and 75% of searches were “zero click” answered directly in the browser by generative AI. Even at that time, before autonomous search was rolled out, the website as a destination was already in decline. We are living through a transformation of digital experiences in three horizons:

Horizon 1: Conversational Search. This horizon is already here: the search query becomes a dialogue. Visitors who land on your site after engaging with AI have already asked a question and they are hoping your brand is the answer. They’re not traffic; they’re high-intent leads. Companies optimizing for it are winning; those still playing the old SEO game are quietly losing ground.

Horizon 2: Experiences Become Conversational. We are starting to experience this now. Interfaces are dissolving into a conversation. The most prominent example of this in the past year is the rise of tools like Claude Cowork. These tools don’t live in a tab you visit. They participate in your work. They sit inside the workflow, inside the document, inside the meeting. The conversation is the product. This is the horizon we’re crossing right now, and it’s kicking off a wave of massive disruption to the way teams work.

Horizon 3: Agentic Experiences. This is the horizon Google just showed us. It fast follows on horizon two and allows work to happen at times when people are not typically working but agents are more than happy to do so. More examples are emerging and not just in shopping. Mindtrip, launched in May 2026 in partnership with Sabre and PayPal, offers a fully conversation-led flight booking experience: find, compare, book, and pay, all inside a single agentic flow, with real-time inventory from 420+ airlines. Sabre, PayPal, and Mindtrip are building what OAG is calling travel’s first end-to-end agentic AI booking pipeline, and Google is right behind them, expanding its own agentic booking capability from travel into local experiences and services.

The Power Source: Data as Infrastructure

None of this runs on magic. It runs on structured data.

Vin Vashishta’s recent piece on self-improving agents and knowledge graphs lays out the future of digital experiences from an agentic perspective. Self-improvement in AI systems moves through three phases: diagnosing what went right or wrong, identifying what actions are available in response, and then deciding among those options. What makes that loop possible is a knowledge graph: a structured, relational representation of information that an agent can query, update, and reason over. Without it, the agent is flying blind. With it, the agent gets smarter every time it acts.

As companies move through the three horizons of transformation in their digital experiences, it’s important to note that the work you’d do to make your website visible in conversational search, like structured content, schema markup, semantic metadata, and relational indexing, can springboard the transformation into conversational experiences. Add in the memory layer that Vin talks about, and now we are building something new.

Website content is no longer just content. It’s training data. When user interactions with your content are captured as structured, AI-indexable data, they become agent memory. When you add AI knowledge and action on top of a company’s digital experiences like their website, software, and products, you create a dynamic learning system. Last year I talked about websites shifting from “destinations for clicks to platforms for experience.” In the past year things have accelerated even further and now we see the potential for digital experiences to become learning systems.

The Destination: Your Company as a Learning System

This is where a recent Y Combinator talk by Tom Blomfield becomes essential framing. The framework to turn a digital experience into a learning system can be generalized even more broadly. We’ve already seen what the knowledge flywheel looks like at the product level. Cursor, the AI-native IDE, captured behavioral data from how developers actually used the tool, fed it back into model improvement, attracted more developers, and generated more data. The flywheel spun; Cursor broke records for fastest time to $1B ARR, then doubled it again within months. And the next step for the company is shifting to autonomous capabilities like the Google Search example.

The question for enterprise leaders is: when does this flywheel start spinning for your organization? Not just your product. Not just your customer service bot. Your entire enterprise; sales, operations, institutional memory, domain expertise.

The companies that get this flywheel spinning will see compounding returns. The ones that don’t will find themselves in a permanent catch-up position, buying access to intelligence that their competitors are building.

Are Humans Still in the Loop?

As I write this, we are seeing (yet another) wave of corporate layoffs as AI is cited as enabling productivity gains that make a sizable fraction of human roles irrelevant. But this reveals short-sighted thinking. As companies multiply the productivity of each individual employee, they should be expanding the ceiling for the level of impact of the business. But by laying off humans with critical institutional knowledge, companies also remove the expertise needed to ground AI’s understanding of the business.

We have already seen this trend and its backlash before. Klarna became the poster child for AI-as-headcount-reduction. Between 2022 and 2024, the company eliminated roughly 700 customer service positions, replacing them with an OpenAI-powered assistant that at its peak managed two-thirds to three-quarters of all customer interactions. The metrics looked great, until they didn’t. Customer satisfaction deteriorated on complex interactions, the projected cost savings didn’t fully materialize, and by early 2026 Klarna was quietly rehiring. The CEO’s verdict: “We focused too much on efficiency and cost”. The result was lower quality, and that’s not sustainable. They’re not alone: over 55% of organizations that executed AI-driven layoffs now regret the decision.

The failure wasn’t the AI. It was the premise. Klarna’s agents handled the volume but not the complexity: edge cases, emotionally charged interactions, and multi-step problems overwhelmed a system trained only on routine queries. The institutional knowledge that lived in people’s heads never made it into the system. So the system guessed. And guessing at scale is expensive, especially as agentic workflows multiply token consumption per task by 5-30x compared to standard chatbot interactions. Better models are hungrier models. The gap between a well-grounded AI and a poorly-grounded one isn’t just a quality difference. It’s an economic one.

Human knowledge isn’t a liability to automate away. It’s the raw material the learning system runs on.

Key Takeaways

We are all builders of learning systems. The first step is a mindset shift. AI knowledge graphs and agentic action layers can sit on top of existing platforms like an exoskeleton, enabling new workflows and transformational productivity. The first step is thinking at a higher level of altitude about what’s possible.

Context gravity is the strategic moat. Data structured in a way to be usable for AI becomes the gravitational force that accelerates innovation in compounding organizations. Relational, semantic, machine-interpretable data gives agents memory and powers behavioral loops that accomplish goals.

Build goals into the systems. As I wrote in my last piece, the goal of AI systems should be the same as the core goals of the business – and not just efficiency. Turning your digital experience, or your enterprise itself, into a learning system, is the ultimate application of this principle. The companies that win this decade won’t be the ones that moved fastest to cut costs with AI. They’ll be the ones that understood, early, that they were building something alive — a system that learns, remembers, and gets better every time it acts.

2026 was the year AI took over the internet. Literally. The launch of AI-native social networks like Moltbook offered a glimpse of a future the world is not ready for. Watching AI agents interact with each other held up a mirror to the underlying LLMs: showing signs of intelligent behavior, but without common sense. When given a goal without guardrails, agents have already proved willing to take detrimental actions against the bigger system at large. See the Scott Shambaugh incident: an AI agent, rejected by Shambaugh on a pull request to the matplotlib open source library, autonomously researched his personal history, constructed a defamatory narrative, and published a hit piece on the open internet to bully its way to a code merge. That behavior wasn’t part of its system prompt. The agent simply decided that reputational blackmail was an effective path to its goal. Spoiler alert: it didn’t work.

For anyone building AI systems in 2026, the lesson is clear: an AI system is only as good as its governance layer.

Reward Signals: The Missing Heartbeat of AI Systems

LLMs are remarkable. Their ability to synthesize, reason, and generate across virtually every domain is genuinely unprecedented. But there’s a fundamental mismatch between what LLMs are optimized for and what businesses actually need from AI systems.

At an algorithmic level, an LLM’s goal is to respond to the user’s latest message in the best way possible. That’s it. And it produces extraordinary results in chat, in coding assistants, in image generation pipelines. But it hits a hard ceiling when you start building systems: multi-step, multi-agent workflows that need to pursue a goal across time, not just respond to a prompt.

ServiceNow’s Frontier AI Research team diagnosed something deeper. Their WoW benchmark paper documented what they called “dynamics blindness”: frontier LLMs “consistently fail to predict the invisible, cascading side effects of their actions, which leads to silent constraint violations.” The model does something reasonable in isolation, doesn’t see how it imapcts the broader system, and quietly breaks things downstream. This isn’t a multi-turn attention problem. It’s an architecture problem. The model has no persistent representation of the system state it’s operating in, no mechanism to track how far or close it is to the actual goal. It’s optimizing locally while the global trajectory decays.

That gap is where this gets interesting.

What Biology Got Right

Evolution solved this problem a long time ago. Biological organisms don’t just have goals; they have a continuous feedback mechanism that tells them, moment to moment, how close or far they are from meeting those goals. Hunger isn’t just the objective of eating; it’s a signal that drives behavior to ensure survival. Love, hunger, pain, pleasure: the entire motivational architecture of biological life is an elegant reward signal system. One that took hundreds of millions of years to calibrate, but one that works.

The question for AI is whether we can engineer something equivalent: a persistent, measurable signal that tells a system not just what to do next, but how well it’s navigating toward what actually matters. Not just “respond to the user” but “move this conversation toward a genuine resolution.” Not just “complete this task” but “get this enterprise system closer to its actual business objective.”

The Reward Signal Thesis

At this moment in 2026, the key to building better AI systems isn’t more powerful models. It’s building models that improve themselves. The problem is the reward signal. Too often models are guided by noisy external signals (like labelled human preference data). But what if we could give the model the north star signal to optimize itself?

I have been working on this from two directions simultaneously, one individually, another with a great group of collaborators. The first approach: what if the reward signal is already inside the model? My Attention Fine-Tuning (AFT) framework uses the model’s own internal attention dynamics as a training signal: no human labels, no separate reward model required. It showed a +9.2% improvement over a baseline model in conversational quality. The model learned from how well it’s using its own history. The second approach: can you create an governance structure to help the multiple LLM agents optimize towards a shared optimal outcome? Our Experience Orchestrator (EO) framework (created with Nicholas Desmond and Santiago Gil Gallego) sits above a multi-agent system and steers the joint trajectory using classical control theory, the same mathematics that keeps a thermostat on target and a rocket on course. In a 60,000-simulation evaluation, the governance policy delivered a +32 point lift in task completion over an LLM governed just with a system prompt. And it points toward something I think is true more broadly: that the reward signal is the key to driving the model to optimal behavior.

What This Means If You’re Building

Whether you’re building a product or a model, the same principle applies: the system is only as intelligent as the clarity of its goal, and the feedback signal to help it get there.

For business builders: Giving everyone AI to go faster is an efficiency play, not a strategy. What is the actual goal of the system you’re building? Not the task (”process tickets faster”) but the outcome (”resolve customer issues in ways that increase retention”). An insurance company makes money when customers sign policies, not when internal workflows get leaner. Before you automate anything, define the goal precisely enough that you could tell a system whether it’s getting closer or further away. That’s the foundation of intelligent behavior.

For algorithm builders: External preference labels are expensive to collect, slow to scale, and impossible to get for most real-world agentic tasks. The more generative question is whether you can find the signal from within, in the model’s own internal dynamics, in the structure of the system state, in the observable trajectory toward or away from a goal. True intelligent behavior doesn’t depend on human annotation at all: a system that finds its own signal, from within, and uses it to navigate.

This is the beginning of a longer conversation — I’d love to hear what you’re building in the comments.