The Protocols Are Being Debated. The Agents Haven't Arrived Yet. The Industry Called It a Revolution Anyway.
A technical deep dive into AdCP, ARTF, and UCP, what they actually do, how they relate, who controls them, and why the governance fight inside the protocol debate matters more than the protocols.
This is a technical deep dive, not a CES recap. We read the specifications so you don’t have to. You’re welcome.
In October 2025, the AdCP coalition staged a controlled demonstration of an agent-to-agent media buy. A buyer agent negotiated with a seller agent. LG Ad Solutions provided the CTV inventory. The brand being advertised was fictional. A non-alcoholic drink invented for the demo. Real money technically changed hands. Two humans were present, approving steps as the agents worked through the transaction.
McKinsey compared it to watching the first banner ad being served.
The comparison deserves a moment. The first banner ad, a 1994 AT&T placement on HotWired, was not a demo. It was a real advertiser, real money, a real audience, and no human watching each impression serve. It fired. The October 2025 demonstration was a controlled proof of concept representing a fictional brand, with two engineers from the two companies present to fine-tune and approve along the way. Calling these the same kind of milestone is the kind of optimism that produces good press releases and imprecise expectations.
That one data point captures the entire state of agentic advertising in 2026. The infrastructure work is genuine. The autonomous-at-scale part remains aspirational. The industry has found this distinction inconvenient and has mostly declined to make it.
Between October 2025 and today, three significant protocol specifications emerged: the Ad Context Protocol (AdCP), the Agentic RTB Framework (ARTF), and the User Context Protocol (UCP, now renamed Agentic Audiences). All three are serious technical work. All three carry the word agentic prominently. None of them, by themselves, delivers an autonomous advertising agent transacting without human oversight at commercial scale. By May 2026, the most credible public data point was one SSP reporting 30 fully autonomous campaigns live, against a market running hundreds of billions of ad transactions daily.
The investor on that earnings call who called 30 campaigns immaterial was arithmetically correct. The more instructive number: every advertiser who ran one came back to run another. These are different signals. The industry has been citing the second as if it disproves the first.
This article examines what the three protocols actually do at an engineering level, how they relate to each other, where they conflict in both technical and governance terms, and what the sufficient conditions for genuine autonomous advertising look like. The specifications have been read. The press releases have been set aside.
* * *
What “Agentic” Actually Means, From First Principles
The word agent in AI research has a precise technical meaning that predates its current marketing career by several decades. The standard definition, established by Stuart Russell and Peter Norvig in their foundational textbook, describes an intelligent agent as a system that perceives its environment and acts upon it. That definition is deliberately minimal. The interesting distinctions come from the properties that separate a genuinely autonomous agent from a very capable automation system.
The four properties are perception, planning, tool use, and autonomous feedback.
Perception: the system reads its environment through data sources, signals, APIs, logs.
Planning: the system sets goals, breaks them into sub-goals, and generates action plans.
Tool use: the system acts through external tools and APIs it can call, systems it can write to, transactions it can execute.
Autonomous feedback: the system observes the outcomes of its actions, compares them against its goals, and updates its strategy without a human approving each step in the cycle.
The fourth property is the only one that separates an agent from a very expensive if-then statement. The first three describe automation. All four together, with the feedback loop closing without human intervention, describe agency.
Most of what adtech labels as agentic in 2026 handles the first three well and installs a human at the fourth. Campaigns are set up by AI. Optimization recommendations are generated by AI. Bid analysis, audience segmentation, pacing reports. All faster and sharper than before. A human reviews, approves the significant moves, and signs off on anything above the budget threshold that the contract specifies. The AI accelerates the work. The human still makes the decisions that cost real money.
There is an accurate word for this. The word is assisted. Assisted is genuinely valuable and represents real progress. It is not the word being used in the quarterly earnings calls.
The spectrum runs through identifiable stages. At the deterministic end: rules-based bidding with fixed CPM floors. No learning, no goal-setting. In the middle: ML optimization systems that adjust bids continuously toward a target metric without per-step human approval. These have perception and self-correction, but their goal is fixed by the human and their tool access is confined to a single platform. Near the fully agentic end: a system that receives a business objective in natural language, decomposes it into a multi-platform media strategy, executes across channels, observes outcome signals from independent measurement sources, identifies underperformance against the stated objective, and revises the strategy, all without a human in any loop.
That last system does not exist in adtech at commercial scale. The three protocols analyzed here are necessary infrastructure for it. They are not sufficient, and the industry has conflated necessary with sufficient, which is the source of most of the confusion.
* * *
ARTF: Brilliant Infrastructure With a Borrowed Label
The Agentic RTB Framework, version 1.0 finalized by IAB Tech Lab in March 2026 with version 2.0 already in active development, solves a latency problem the industry has lived with since roughly 2015 and discussed at conferences since roughly 2016. The problem is worth explaining carefully because the specification’s solution is the most technically rigorous piece of work in the current protocol landscape, and that technical rigor deserves to be understood separately from what the marketing around it implies.
The current RTB architecture requires any enrichment of a bid request to traverse a network. An SSP receives a bid request from a publisher, wants to apply fraud scoring, contextual categorization, audience segment matching, or custom bidding logic, and calls the relevant vendor’s API. That call crosses the open internet to a separate data center, gets processed, and returns. The round trip runs 600 to 800 milliseconds. The auction timeout is typically 100 to 300 milliseconds. The enrichment loses the race more often than it wins. The bid exits without the data, or misses the auction entirely. The data vendors selling enrichment services are delivering a product the architecture physically cannot use in time.
ARTF’s solution is co-location through containerization, and the concept connects directly to a principle that has transformed every other layer of software infrastructure: edge computing.
Edge computing’s organizing idea is that the latency bottleneck in distributed systems is usually the distance between data and compute, and the solution is to move the compute closer to the data. Content delivery networks do this for web assets: instead of serving a video from a single origin server, it is cached at nodes physically close to end users. CloudFlare Workers, AWS Lambda@Edge, and similar platforms let application logic run at the network edge, cutting hundreds of milliseconds of round-trip latency to single-digit milliseconds. The principle is the same wherever it is applied: reduce the physical and network distance between where the data is generated and where it is processed.
ARTF applies this principle to the RTB bidstream. Rather than the SSP making a cross-internet network call to a vendor’s API, the vendor’s logic is packaged as a container and deployed inside the SSP’s own infrastructure like same data center, same server, or same Kubernetes cluster as the auction engine. The enrichment runs locally. There is no network hop. The 600-millisecond round trip becomes a local function call measured in microseconds. IAB Tech Lab’s specification documents claim up to 80 percent reduction in bid request and response time, from 600-800ms to approximately 100ms.
The technical architecture is more precise than the summary suggests. When a host platform (SSP, DSP, exchange, or ad server) invokes an agent container, it passes a defined subset of the bid request data to the container. The container applies its logic and returns an OpenRTB Patch: a structured set of proposed mutations, each tagged with a declared intent. An intent might be fraud_detection, contextual_enrichment, identity_resolution, deal_activation, or bid_adjustment. The host platform reviews the proposed mutations, applies its own policy, and merges approved changes into the live bid request before the auction proceeds.
The mutation-with-declared-intent model is a deliberate design choice with consequences. Containers propose. The host decides. A fraud container can flag an impression as high-risk and propose its removal, but the orchestrating SSP can override. This means an ARTF container is an intelligent specialist, not an autonomous decision-maker. It has deep expertise in its narrow domain. The consequential decisions about which bids to send, which deals to activate, which impressions to accept, remain with the host platform.
The security specification is explicit and strict. Agent containers have no external network access. All network ingress and egress is prohibited except for communication with the orchestrating host. A container running inside an SSP’s infrastructure cannot call home to the vendor’s servers, cannot exfiltrate bid data, and cannot make secondary API calls during execution. This is the same security model that edge compute platforms apply: the code runs in a sandboxed environment with access only to what the host explicitly provides. The serialization protocol is gRPC with protobuf rather than HTTP with JSON, chosen specifically for lower latency, smaller payload size, built-in schema validation, and better support for streaming patterns.
The pre-ARTF existence of this architecture in production is worth noting for its implications. The Trade Desk’s engineering team developed a custom container-based bidstream augmentation solution with Chalice Custom Algorithms, the custom AI bidding specialist, before the IAB Tech Lab specification existed. Adam Heimlich, CEO of Chalice, confirmed support for the standard at launch and noted the interoperability benefits. What was a bespoke bilateral integration becomes, through ARTF, something any host platform can implement and any vendor can deploy into. Standardization is not glamorous, but this is exactly what standardization is for.
The honest evaluation of ARTF: the engineering is correct, the latency problem is real, the containerization model is proven in adjacent infrastructure contexts, and adoption will come because the specification asks the industry to change architecture rather than business model. The word agentic in the framework’s name is defensible in the narrow sense that the containers are services with perception and action capabilities. It implies a level of goal-directed autonomy that the specification does not claim and the containers do not exercise. Both observations can coexist without contradiction.
* * *
AdCP: The Coordination Layer and the OpenDirect Question
The Ad Context Protocol is the most ambitious of the three specifications and the one generating the most institutional disagreement. It is built on Anthropic’s Model Context Protocol, governs a different time scale than RTB, and targets a category of advertising transaction that the industry has been failing to automate for a decade under a different name. The different name is OpenDirect. This context belongs at the beginning, not the end.
In January 2015, IAB released OpenDirect 1.0, a specification designed to standardize the automated buying and selling of premium direct-sold inventory. The problem OpenDirect was solving: the request-for-proposal and trafficking process for guaranteed direct deals was human-mediated, slow, error-prone, and could not scale. OpenDirect defined a standard API for inventory discovery, campaign setup, order management, and pricing. Implemented on both sides of a transaction, it would allow a buyer’s system to negotiate and configure a direct deal without a human emailing a spreadsheet. OpenDirect 2.0 followed in 2021 with updated features and renewed industry commitment. OpenDirect remains available on GitHub. It is implemented by a minority of platforms. The direct deal process still runs largely on email and spreadsheets, with meaningful OpenDirect adoption concentrated in specific regional markets rather than as a general standard.
AdCP is attacking the same structural problem. Understanding what is different requires understanding AdCP’s technical foundation.
Anthropic’s Model Context Protocol, published in late 2024, answers a specific problem in AI application development: how does a language model connect to external tools and data without custom integration code per tool? Before MCP, every connection between an LLM and an external system required bespoke engineering as in a custom API client, a custom authentication handler, a custom response parser, and ongoing maintenance as external systems changed. MCP standardizes the interface: every tool declares its capabilities in a common schema, and any MCP-compatible model can discover and invoke those capabilities without custom code per tool. By late 2025, the MCP SDK had recorded 97 million monthly downloads across more than 10,000 active servers deployed globally. Anthropic transferred MCP governance to the Linux Foundation in December 2025, with OpenAI, Google, Microsoft, and AWS each confirming support.
AdCP takes MCP as its foundation and adds an advertising-specific coordination layer on top. Where MCP defines how agents connect to external systems generally, AdCP defines what advertising platforms need to expose and understand for agents to negotiate and execute campaigns. The protocol has three deployed modules and one pending.
The Signals Activation Protocol defines how a buyer agent discovers and activates audience signals. Every AdCP-enabled publisher maintains an adagents.json file, a machine-readable declaration of the publisher’s properties, agent endpoints, available audience data, governing consent frameworks, and activation conditions. A buyer agent reads this file and understands what is available before opening a deal conversation, without a human logging into a publisher portal or a sales team picking up the phone. The adagents.json structure is conceptually similar to ads.txt and sellers.json, which the industry already reads at crawl time for supply chain validation. The difference is that adagents.json is read by an AI agent constructing a media strategy, not a crawler checking chain of custody.
The Media Buy Protocol defines how buyer and publisher agents negotiate deal terms. The buyer agent sends a structured brief specifying target audience, flight dates, pricing constraints, brand safety requirements, creative formats, and performance goals. The publisher agent responds with available inventory, contextual data, pricing options, and deal structure. The negotiation proceeds asynchronously, not in 100 milliseconds, but over whatever time frame the business decision warrants. Publisher-side agents can auto-approve campaigns meeting predefined criteria and route larger deals for human review. This asynchronous design is what makes AdCP suited for the deal types where context and relationship matter: programmatic guaranteed, private marketplace, CTV direct, DOOH, audio.
The Creative Protocol defines how buyer agents describe creative assets in structured metadata that publisher agents can parse. Rather than a URL pointing to a static file, an AdCP creative declaration includes format specifications, contextual targeting applicability, brand safety classifications, and for dynamic creative, the decision logic for variant selection. For DOOH and CTV, where creative appropriateness is inseparable from screen context and moment, this matters considerably more than it does for display.
The Curation Protocol, expected later in 2026, defines how deal IDs, PMP packages, and curated audience segments surface to buyer agents as machine-discoverable capabilities. This is the module that most directly challenges the current human-mediated curation sales process, and therefore the one most likely to generate institutional resistance proportional to its utility.
AdCP does not replace OpenRTB. The buyer agent uses AdCP to negotiate the deal and define the terms. OpenRTB then executes impression-level auction against the resulting deal ID at sub-100 milliseconds. AdCP is the contract negotiation. OpenRTB is the delivery.
So why will AdCP succeed where OpenDirect did not? The coalition has made two specific bets. The first is that MCP substantially lowers integration cost. OpenDirect required publishers and buyers to design, build, and maintain a custom API product. MCP-based AdCP integration means any MCP-compatible AI model can discover and invoke an AdCP endpoint without custom code per integration. The second is that AI agents change the demand economics. A human media buyer could not operate 500 simultaneous direct deal negotiations. An AI buyer agent can. The supply of publisher relationships that could be automated existed in 2015 but could not be extracted because the automation infrastructure did not. Whether these two changes are sufficient to overcome the commercial dynamics that defeated OpenDirect is the most important open question in adtech infrastructure right now, and it has an empirical answer that will be clear within 18 months.
Anthony Katsur, CEO of IAB Tech Lab, has publicly called AdCP deeply flawed and resource consuming, arguing that the Tech Lab’s existing standards already address what AdCP claims to solve. The criticism has technical substance. There is genuine overlap between AdCP’s scope and what extended IAB standards could cover. It also comes from a body that governs the existing programmatic infrastructure. AdCP, at its most ambitious, creates an agent coordination layer that routes around meaningful portions of that infrastructure. Reading the criticism with awareness of the institutional position from which it comes is not an accusation of bad faith. It is basic analytical practice.
* * *
UCP: The Protocol That Holds the Stack Together
The User Context Protocol, donated by LiveRamp to IAB Tech Lab on November 3, 2025, and formally renamed Agentic Audiences, is the foundational data layer that neither AdCP nor ARTF can function optimally without. It receives roughly one-third the conference stage time of the other two protocols, partly because it requires explaining embeddings before it makes sense, and partly because it does not have a dramatic origin story involving a fictional beverage brand.
The problem: when a buyer agent negotiates with a publisher agent through AdCP, both sides need to describe audiences. When an ARTF container performs identity resolution or audience enrichment in real time, it needs to represent and compare audience signals. The current method for expressing audience identity in programmatic involves hashed email addresses, cookie-based user IDs, segment membership lists, and proprietary identity keys that do not map cleanly across platforms. These representations are verbose to exchange, slow to compare, increasingly constrained by privacy regulation, and fundamentally fragmented.
UCP’s answer is embeddings. An embedding is a dense numerical vector that encodes the semantic meaning of something in a format machine learning systems can process efficiently. Rather than a list of segment memberships or a raw identifier requiring a panel match, systems exchange a learned vector that encodes the audience signal itself. The specification defines vectors ranging from 256 to 1,024 floating-point dimensions. Comparing two embeddings requires computing cosine similarity, a dot product normalized by vector magnitude which modern CPUs execute in microseconds across millions of comparisons per second. Comparing two segment membership lists requires set intersection across potentially hundreds of segments in different taxonomies. For ARTF containers operating within the auction’s time budget, this is not a marginal efficiency gain.
UCP defines three signal layers. The identity layer represents who the user is in a privacy-preserving format, attributes at a level of abstraction that cannot be trivially reversed to personally identifiable information. The contextual layer encodes the current session: content being consumed, time of day, device, behavioral signals from the active visit. The reinforcement layer encodes historical advertising response: which formats drove completion, which creative characteristics performed, which frequency levels produced saturation versus incremental effect.
The governance detail is worth stating clearly. UCP now resides in IAB Tech Lab’s GitHub repository. AdCP, governed independently by AgenticAdvertising.org, depends on a signal format standardized by the body whose CEO called AdCP deeply flawed. This is not necessarily a problem as open standards governance has worked in adversarial conditions before. It is a dependency that produces a specific structural dynamic: IAB Tech Lab controls the data layer that makes AdCP most efficient. This gives the Tech Lab indirect leverage over AdCP’s performance even if AdCP achieves broad adoption. Whether that leverage is exercised consequentially is a future variable, not a current fact.
* * *
The Stack, the War, and the Question Nobody Is Asking Directly
The logical relationship between the three protocols is a stack. UCP defines the data format for audience signals. AdCP defines the coordination protocol for agent-to-agent deal negotiation using those signals. ARTF defines the execution infrastructure for how agents operate inside the RTB auction using those same signals in real time. Each layer addresses a distinct problem. The architecture has internal coherence.
A buyer agent using AdCP negotiates a CTV campaign using UCP-formatted audience embeddings to describe the target audience in a format the publisher agent can compare directly against its available signals. When the deal executes, ARTF containers inside the SSP apply identity resolution and contextual enrichment in real time, in compatible embedding format, within the auction’s latency budget. The protocols are designed to interoperate. Technically, the stack works.
Governmentally, it is more complicated.
AdCP is governed by AgenticAdvertising.org, a new independent organization formed last year. ARTF and UCP are both governed by IAB Tech Lab, the established industry organization. These are not neutral parties in the same debate. IAB Tech Lab is the standards body for the existing programmatic infrastructure. AdCP, in its most ambitious form, routes around meaningful portions of that infrastructure. When Katsur calls AdCP deeply flawed, and when O’Kelley argues that adtech needs an open coordination layer independent of the existing standards body, they are making technical arguments that are also commercial and institutional arguments. The protocol debate is real. It is also a proxy for the more consequential question: who writes the rules for AI-mediated advertising transactions as that market matures?
Nobody is discussing this directly as a governance question, because governance questions do not have obvious answers and are harder to keynote than protocol comparisons. But the dollar value attached to controlling the standards layer of an industry measured in hundreds of billions annually makes the governance question the more important one. Observers following this debate should track it as a standards-war question alongside the technical one.
* * *
Seven Things the Industry Is Not Saying Clearly Enough
ARTF is infrastructure engineering wearing an agentic badge because 2026 requires agentic in the name. The problem it solves has been documented since 2015. The solution of co-locating compute with data, reducing the enrichment call from a network traversal to a local function call is the edge computing principle applied to RTB. The specification is technically rigorous. The container security model is correctly designed. The gRPC and protobuf serialization choices are right for the latency requirements. None of this requires the word agentic to be true. The word is there because that is the current vocabulary, and current vocabulary is how standards get adopted. This is observation, not criticism.
AdCP is OpenDirect 2.0 with a better technical foundation and an unresolved adoption question. The MCP foundation genuinely lowers integration cost in a way OpenDirect’s custom API approach did not. The AI agent demand dynamic genuinely changes the economics of publisher-side implementation in a way that did not exist in 2015. Whether these two differences are sufficient to produce different adoption outcomes than OpenDirect achieved across two versions is an empirical question with a known answer timeline. If broad two-sided adoption is not visible by mid-2027, the OpenDirect parallel will be difficult to avoid.
UCP is the most technically important protocol of the three for production deployment and the least discussed at industry events. Both of the other protocols perform better with UCP-compatible embedding infrastructure than without it. The industry is debating the protocols at the coordination and execution layers while the data layer remains in early community development. Building floors before the foundation is standardized is a common industry error with known consequences.
The controlled October 2025 demonstration was not the first autonomous advertising transaction in the way the first banner ad was the first online advertising transaction. The first banner ad was a real advertiser buying real reach with no humans watching each impression. The October 2025 demo was a proof of concept for a fictional brand, with engineers from both companies present, in a controlled environment. Calling these equivalent milestones creates expectations the current technology does not meet. This matters because unmet expectations produce the disillusionment that causes genuinely good infrastructure to be written off before it matures.
The governance war is the real story. The technical differences between AdCP and ARTF are worth understanding. The governance question of who controls the standards layer for AI-mediated advertising is the question that determines which technical approach shapes the industry at scale. It is not being discussed in those terms because governance wars are less conferencing-friendly than protocol comparisons.
No measurement protocol exists for the agentic future, and nobody seems to be in a hurry to build one. Autonomous agents improve through feedback loops. Feedback loops require outcome data that arrives faster than a quarterly MMM cycle and is more accurate than last-click attribution. The ANA’s December 2023 study found that only 36 cents of every dollar entering a DSP effectively reached the consumer. The remaining 64 cents distributed through a decision chain that is not fully legible to any single party. Autonomous agents making allocation decisions on top of broken measurement inputs will automate the existing problems more efficiently, not transcend them. Three protocols address execution. Zero address measurement.
None of the protocols currently mandates that autonomous decision logs be accessible to advertisers. A genuine agentic system produces a complete audit trail of every decision, which signal drove which allocation, which bid strategy was applied, why. That log is simultaneously the mechanism by which agents improve and the most comprehensive supply chain audit the industry has ever been positioned to produce. Whether it is accessible or internal to the platform running the agent is a design choice, not a technical constraint. The specifications leave this choice to the implementers. The implementers’ commercial incentives do not uniformly point toward accessibility.
* * *
What Genuine Agentic Advertising Actually Requires
Genuine autonomous advertising agentic systems that set goals, execute across platforms, observe independent outcome signals, and revise strategy without per-step human approval require five conditions that the current state of the industry does not meet. The protocols being built address one of the five. This is important context for evaluating the timeline claims currently in circulation.
First: interoperable identity that works across the open web without bilateral matching agreements. UCP’s embedding approach is the most promising technical candidate in the current landscape. It is not yet a standard. It is a proposal in active community development. Every agentic capability that depends on matching audience signals across platforms depends on this layer being stable and broadly adopted. Every timeline for autonomous agents that does not specify when identity interoperability arrives is incomplete.
Second: outcome measurement that closes the feedback loop within the campaign window. Agents that observe outcomes quarterly cannot update strategy within a campaign. Agents that rely on platform-reported attribution are optimizing toward a metric the platform controls. Independent, timely, cross-platform measurement is not a nice-to-have for autonomous advertising, it is the mechanism by which the autonomous part works. Without it, what is being automated is the execution, not the intelligence.
Third: standardized tool access across platforms via protocols like AdCP. This condition is being actively addressed. The rate at which buy-side and sell-side platforms implement working AdCP endpoints determines the rate at which buyer agents can operate across the open web without falling back to human negotiation. The protocol is correct. The adoption timeline is the variable.
Fourth: accountability structures for decisions made at autonomous scale. When a guardrailed autonomous agent makes a decision that produces a brand safety incident, or burns significant budget on demonstrably wrong inventory, the legal and contractual question of responsibility is not currently resolved. The industry is running a proof of concept at small scale while the liability frameworks are incomplete. This works at 30 campaigns. It becomes consequential at 30,000.
Fifth: commercial incentives that reward transparency in the decision layer. An autonomous agent’s decision log is the complete record of every allocation decision, every signal consulted, every tool called and is the most comprehensive supply chain audit the industry has ever been positioned to produce. It is also a direct threat to every margin that currently exists in the opacity of programmatic decision-making. Whether the industry builds the agentic future in a way that makes this log accessible or maintains it as internal platform data is not a technical question. It is a commercial choice, and the commercial pressures point in both directions simultaneously. The protocols do not resolve it. The contracts will, eventually, and the outcome will either validate or undermine the transparency claims attached to agentic advertising.
* * *
The Honest Summary
Three protocols exist. All three are doing serious work. ARTF addresses a real latency problem with correct engineering, will achieve meaningful adoption because it asks for architectural change rather than business model change, and is correctly labeled as agentic in the narrow sense that containers are specialist services with perception and action capabilities. AdCP proposes a genuinely novel coordination layer for agent-mediated deal negotiation, is built on a sounder technical foundation than its OpenDirect predecessor, and faces the same adoption challenge that defeated that predecessor across two versions and a decade. UCP provides the data layer both other protocols need to function at their stated potential and is the least mature of the three in terms of standardization.
Thirty campaigns at one SSP early this year is a proof of concept, not a revolution. Every advertiser who ran one came back to run another, which is the correct signal to watch: not the absolute number but the repeat behavior. Repeat behavior means the technology is useful enough to choose again. It does not mean scale has been achieved. The distance between useful enough to repeat and deployed across the industry at autonomous scale contains all five of the conditions listed in the preceding section, none of which the protocols by themselves resolve.
The agents have not arrived. The protocols have. The industry called both the same thing, which generated excellent conference programming and imprecise expectations. The protocols are necessary infrastructure for the autonomous future being described. Necessary infrastructure is valuable. It is also not the same as the future being described, and the industry’s habit of conflating the two will produce a disillusionment cycle that the good engineering underneath does not deserve.
The soup is real. Some of it is nutritious. The menu promised something more elaborate. The kitchen is still being built.