Specs without enforcement are suggestions.
Digital advertising is held together by published specifications that no runtime enforces, and by failures those documents do not name. The work here is open-source tools and measurements for that gap: validators anyone can run, and the papers underneath them.
The problem this exists for
A bid request, an ad tag, and a tracking pixel each cross a boundary between two companies that never see each other’s code. The IAB Tech Lab and the Agentic Advertising Organization publish what some of those artifacts should look like. Nothing checks that they do, and a lot of the failure is outside those documents entirely. When a payload is malformed, the failure is silent: the auction is lost, the slot renders blank, the conversion is never attributed. Nobody gets an error, and the money is already spent.
Compilers and linters solved this for software decades ago. Ad tech never got the equivalent, because the tooling that exists is fragmented into vendor-specific helpers, enterprise auditors priced for holding companies, and schema validators that know nothing about how ads actually work.
The consequences are not confined to one company’s books. The same unchecked handoff shows up four different ways across an industry that took in $259 billion in the US in 2024:
- Revenue leaks. Impressions bill for creative that renders nothing, and the loss is invisible because every system in the chain reports success.
- User data travels unreviewed. Tracking URLs are where identifiers actually move, and they are the least inspected artifact in the pipeline. Raw email addresses, credentials in query strings, and trackers on plaintext HTTP all ship to production routinely.
- Fraud becomes indistinguishable from error. Downstream, a malformed payload and a fraudulent one look the same, because neither can be verified. When the verification resources that exist to catch this are missing or misdeclared, nothing independent measured the impression at all.
- Autonomous systems transact without a verifier. Agentic buying standardized the speed of the transaction and not the correctness of the payload inside it.
Closing those four gaps is what this work is for. Not by writing another specification, but by making the failures mechanically checkable by anyone on either side of any handoff, at a price of zero, including the ones the documents do not name.
Who builds this
OpenAdTech is maintained by Alex Sekowski. Connected-TV ad serving and ad-tech infrastructure, nearly fifteen years. That is where the argument on this site comes from: both sides of these handoffs, integrations that fail between companies that cannot see each other’s code.
The measurements behind these tools are published as preprints, so the claims on this site have something underneath them. Five are out: one measuring how much of IAB privacy signaling a receiver can check versus what a check decides, one measuring why CTV fraud keeps working once the buyer cannot observe the render, one quantifying how much of the OpenRTB specification any validator can enforce even in principle, one measuring the dialects client-side header bidding actually speaks, and one benchmarking whether structural VAST validation is cheap enough to run inside a live bid pipeline. All five are free to read, with datasets and code published alongside.
OpenAdTech is independent personal work. It is not funded, directed, or endorsed by any employer, past or present, and speaks for nobody but its maintainer.
Why it exists
Inside a platform at this scale you see the same class of failure over and over, and how little of it is anyone’s fault. A tag arrives malformed. The player does what the spec says to do with a malformed tag, which is very little. The impression bills. Weeks later somebody argues about a discrepancy report, and neither side has evidence, because the only shared contract between two engineering teams at different companies was a PDF.
That gap does not close by writing another spec. It closes by making the failures mechanically checkable, on both sides of every handoff, cheaply enough that nobody has to justify the cost. Work started with VAST, the artifact where a single bad character costs the most, and works outward to the bid request in front of it and the measurement pixel behind it.
How it is built
Every tool follows the same design, which is what makes them the same to adopt:
- A Rust core, compiled everywhere. One engine becomes a CLI, a WASM module, a native library, language bindings, and an MCP server. Your CI, your browser, your BEAM service, and your agent get identical verdicts, because it is identical code.
- Every rule cites its source. The spec section, the XSD, the RFC, the ISO list, or the documented revenue impact. If a rule cannot cite something, it does not ship. That is what makes a finding arguable with a partner rather than an opinion.
- Fast enough to sit in the path. Sub-millisecond on a typical tag. A validator that adds latency to serving is a validator that gets removed from serving.
- Structured output. Stable rule ids, severities, locations, fix guidance. Readable by a person in a terminal and by a model in a loop.
- Apache 2.0, free forever. No paid tier that hides rules, no cloud version that requires an account, no rate limits, no telemetry without opt-in.
Relationship to the standards bodies
OpenAdTech is an implementer, not an author. The specifications come from the IAB Tech Lab and, for the agentic layer, from the Agentic Advertising Organization and its Ad Context Protocol. The maintainer participates in IAB Tech Lab working groups, including the Advanced TV Working Group, follows the working drafts, and has demonstrated a VASTlint-based VAST tester at an IAB Tech Lab workshop. The maintainer holds the AdCP Practitioner and Governance Specialist credentials from the Agentic Advertising Organization.
The more useful form of participation is code. Implementing a specification closely enough to validate it surfaces the places where the specification itself is wrong, ambiguous, or untested, and those findings belong back with the people who maintain it. Patches go to both organizations’ specifications and reference implementations.
Why open source is the only version of this that works
A validator that costs money is a validator most of the supply chain will not run, and a conformance check that only one side of a transaction can afford does not create interoperability. It creates leverage. The tools have to be free, auditable, and installable in one command, or they do not do the job they exist for.
Get in touch
Bug reports, rule proposals, and spec corrections are welcome on any of the repositories. For anything else, hello@openadtech.org.