Doing It Backwards
Why AdCP was built in public: to make a working standard, not standardize what works
The most curious man in ad tech, Andrew Kraft, challenged me recently:
What I wonder about, though... is why start with a protocol? It took you years to be willing to let DSPs use OpenRTB... it was our API or nothing... in large part because OpenRTB v1 wasn’t ready for all the advanced features we had. But that period gave us and others time to innovate, which then got pushed into OpenRTB. I hear from so many “we made so many mistakes last time, so we know what we now need”... only, we built something that was optimized not allocated.
There are so many questions we don’t even know to ask yet... but my concern is that if we standardize too early, yes we’ll be fast, and we will innovate on the tools that do the work, but we won’t innovate on the work itself.
He wasn’t wrong. Most protocols in ad tech follow the same pattern. Somebody builds it inside a company, proves it works in a controlled setting, cleans up the parts that are embarrassing, and then releases a polished artifact to the world with a press release. The public version is the second or third draft. The messy part happens where nobody can see it.
Here’s what I wrote back:
I see this as good for the industry in that we’re not trying to use protocol as a competitive advantage (as AppNexus and Google did last time around), and as a way for many people to bring in their experiences and ideas to make it better from the beginning.
To your work-vs-tools point: everything we’re doing is about getting the first pilots and test buys to work. The protocol is in service of effectiveness. I hope you know that I’m not doing any of this for academic reasons. This is why ADCOM and OpenDirect and the other specs Tech Lab keeps talking about are not being used at all. They’re not solving the business problems that matter.
You should join the Slack community if you’re not in there. Pretty great group of people.
Building in the open means the messiness is everyone’s messiness. You ship the rough draft. You let people criticize it before it becomes the de facto standard. You accept the real risk that somebody finds a fatal flaw and the whole thing dies, because that is not a bug of the process. It’s the point of the process.
Andrew’s concern is that standardizing early freezes the thinking before the thinking has matured. The protocol becomes a lens through which all subsequent innovation gets refracted, and the things the protocol didn’t imagine become invisible.
The alternative isn’t more innovation. It’s ten incompatible approaches, each optimized for its creator’s commercial position, none of which can learn from the others because they don’t share a language. That is what happened with OpenRTB, which still has no supported libraries, no compliance frameworks, no reference implementations, and can’t convince its own community to upgrade to a better version.
The work itself doesn’t happen in private either. It happens in the first hundred pilots. In the issues filed by implementers who find the edges the architect didn’t anticipate. In the feature requests that turn into rc.1 and rc.2 and rc.3. Standardizing early doesn’t freeze the work. It creates the shared surface on which the work becomes legible to everyone at once.
A few people have said, somewhat jokingly, “it seems like you do all the work on AdCP. Is it just the Brian O’Kelley show?”
When one person builds something coherent, the coherence is the value. You can feel it in Linux, in Python, in Git. One mind, or a very small number of minds, working through the design produces a kind of internal consistency that committees cannot produce. The parts fit. The exceptions feel principled rather than negotiated.
It’s also what risks tearing the project apart. The single architect becomes the single point of failure. Linus became famously difficult. Guido walked away from Python after PEP 572. Projects with strong original authorship almost always hit a moment where the architect either becomes a bottleneck or becomes hard to work with, and the project has to survive that transition or die.
A lot of them die. Most protocols that had a founder never successfully handed off. The ones that did, like Linux past Linus’s temperamental years, Python post-Guido, Git in its decade of quiet maintenance, handed off because the founder built a community capable of holding the ideas without the founder holding them.
That’s the only success condition that matters. Not the elegance of the original design. Not the founder’s intentions. Whether the community can hold the protocol when the founder is no longer in the room.
Prebid is what it looks like when that transition works.
I wrote the first implementation of header bidding. That was the hack: a proof that you could give publishers a way to expose their inventory to multiple demand sources in parallel, before the ad server got involved. That part was mine.
Prebid itself, the open-source project, wasn’t. It was a team at AppNexus, years later, when AppNexus was a much bigger company than it had been in the header bidding days. I was the executive, not the code author. Prebid belonged to the team that built it. The handoff from me to them had already happened by the time Prebid existed, which is part of why it worked.
Then the team handed off to the community. AppNexus didn’t control Prebid. Prebid.org formed. The codebase expanded. Contributors arrived from companies that competed with AppNexus. The project survived AppNexus being acquired by AT&T, then sold to Microsoft. It survived me leaving AppNexus, and leaving ad tech for a while, and coming back to do something else entirely. It didn’t just survive. It got better.
The core concept of Prebid is largely the same as it was at the start: that monetizing the web should be open to anyone. That was the founding bet, and it held. The community kept the bet. They improved the code, expanded the ecosystem, navigated the politics, absorbed new members, fought the fights that needed fighting. Today, most people in ad tech have no idea I was involved at all. That is the cleanest success signal I can point to.
Prebid is now, arguably, the true RTB spec for the industry. It had an architect, then a team, then a community, and became the standard to monetize trillions of ads a year.
I don’t claim credit for this. The team did the work. Then the community did the work. I built the hack, rallied the ecosystem, and eventually let go so it could thrive without me. The handoffs are the point, not the original authorship.
That’s the model. That’s what I want AdCP to become.
So when I started AdCP, I built the handoff in from the start.
It took at least two years after Prebid opened up for Prebid.org to exist as a legal entity. With AdCP, it took two months. AgenticAdvertising.org was incorporated before the protocol was anywhere near ready. The charter, the voting classes, the IPR policy, the working group structure, the antitrust policy. All of it exists now, before GA, because none of it can be retrofitted. A standard that waits until it’s powerful to organize its governance becomes a standard whose governance is shaped by the power dynamics already in place.
Two months versus two years is not a coincidence. It’s the specific thing I learned from Prebid.
The interim board has four directors. Two are from Scope3: Michael Blum (our Chief Legal Officer) and me. The other two are Benjamin Masse from Triton Digital (part of iHeartMedia) and Pia Malovrh from Celtra. Having two Scope3 directors isn’t ideal, but it reflects the fact that Scope3 did the foundational work and that foundations need someone to sit in them while the house gets built. The concentration is a starting condition, not a stable state.
On May 6, 2026, AAO elects its first board. Equal representation across four voting classes: brands, agencies, publishers, technology providers. Ten seats per class. Staggered three-year terms. Two-consecutive-term limit. An executive committee drawn proportionally across classes. My role becomes whatever the elected board decides it should be.
That is the specific moment the handoff begins. Not a vague future. Not “eventually.” A date.
Andrew’s concern is still worth sitting with, because there’s a version of this where he’s right. He’s right if building in the open produces a spec so exposed to criticism that it gets pulled apart before it can stand up. He’s right if the protocol doesn’t work because we didn’t dog-food it internally first. He’s right if the early pilots fail because we didn’t hide the dirty laundry behind a corporate veil.
The last three months suggest otherwise. Real criticism in public produced real revisions across three release candidates. The Swivel and Scope3 live demo in October tested the thing in front of an audience, and it worked. Implementers from companies that compete with Scope3 have shipped against the spec. The costs of building in the open are real. So far the benefits have been bigger.
There’s a deeper version of Andrew’s concern that deserves its own answer. What if the abstractions in AdCP 3.0 are wrong? What if the taxonomies are wrong, the primitives are wrong, the governance model itself is wrong?
The honest answer is that I don’t know, and neither does anyone else yet. Some of the abstractions in 3.0 will turn out to be wrong. That’s true of every protocol that has ever shipped. What matters is whether the machinery for discovering this and fixing it is already in place.
The three RCs revised abstractions in public. The elected board arriving in May has authority over the spec roadmap. Working groups can propose changes. The repo is Apache 2.0, which means it can be forked if governance ever breaks down, and the credible threat of forking is what keeps governance honest. If The Trade Desk wants to fork AdCP, fine. Let’s see if they earn (or buy) trust better than we do.
That’s what it means to ship a protocol whose governance was designed before its features were. The features can be wrong. The governance has to be right.
The question for AgenticAdvertising.org, and for AdCP, is not whether I can step away. I’ve done that before. The question is whether AdCP is strong enough as a protocol, and AgenticAdvertising.org is strong enough as an organization, that when I do, the thing keeps working.
I believe it is. The elected board arrives in weeks, not years. The specification has been shaped by a large group of people who don’t work for me and who will have more authority over it next month than I do.
AdCP 3.0 ships today. It’s the best version yet. The next one will be better, and I’ll have less to do with it than I did with this one.
That’s the success condition.