The hardest part of autonomous buyer and seller agents isn't the AI — it's the state, trust, and observability to run in production. Learn how buyers and sellers clear that bar on one platform.
by Joe Hu, Mandy Baker and Luke Barnes Every day, billions of dollars of advertising change hands through a process that has barely changed in decades: emails, spreadsheets, PDFs, and phone calls. A buyer sets a campaign, then skilled teams reach out to publishers, send RFPs, wait on rate cards, compare media kits, and negotiate price before finally cutting an insertion order. Talented people spend most of their time coordinating the transaction instead of managing the strategic and creative work.
The friction comes from fragmentation. There is no standardized way to discover inventory, evaluate audiences, or establish trusted relationships across partners, so every buyer and seller connection becomes a bespoke integration. Because that coordination takes days, decisions often get made on information that is already hours or days old. Inventory, pricing, and audience signals move continuously, and by the time a campaign is approved the best opportunity may have passed.
The rise of agentic workflows unlocks an opportunity for these teams to remove the manual, repetitive coordination from the equation so they can spend their time where judgment matters most: sharper targeting, better creatives, and campaigns that are not just faster to launch but more effective.
The last wave of AI made software that answers. The next wave makes software that acts — agents that pursue a goal, make decisions, call tools, and transact on your behalf. That's the coordination work the manual media buy is drowning in: reading a brief, researching publishers, comparing rate cards, negotiating price, cutting the order. For the first time, multi-agent systems using LLMs and protocols like MCP can run that loop automatically.
But automation alone isn't enough. IAB Tech Lab's Agentic Advertising Management Protocols (AAMP) standards establishes a consistent communication pattern: a shared vocabulary for inventory and audiences (AdCOM, the taxonomies), a common transaction protocol (OpenDirect, OpenRTB deals), and a registry model for discovery and trust. You could solve this with AI and no standards between two parties. However, standards are what let the entire industry move together, so that any compliant buyer agent can transact with any compliant seller agent, the way any browser can load any website.
The open standards define what agents say to each other. The next question is where those agents actually run: their state, their models, their identity, their governance. That's where Databricks comes in.
We built an example of agentic media buying and selling fully on Databricks. Autonomous buyers and sellers discover each other, agree on price, and close deals. It’s built on the official open source IAB Tech Lab Software Development Kit (SDK) so there's no lock-in at the protocol layer, and now available as an accelerator that you can deploy with a single command. Instructions are at the end of the blog.
An agentic media buy is a simple transaction with three players:
The buy itself is a short loop: discover which sellers have the right inventory, price it, and book the deal (or walk away). Today that loop is largely manual; the shift we're demonstrating is running it with AI agents on both sides.
Agents from different companies need a shared language to transact, and that’s where IAB Tech Lab’s open standards can add value. We won’t cover the details of their SDK here but instead focus on what it takes to run buyer and seller agents on Databricks.
Complex agents go far beyond simple requests to a Large Language Model. In order for these agents to run a media transaction, which could involve a variety of tasks such as planning an audience, splitting a budget, discovering publishers, honoring a price ceiling, and booking the deal, you need a system that manages:
This system can be assembled from a database vendor, a model host, a governance tool, an app platform, and a tracing service. On Databricks, it's one platform.
Start with a fact about this market: the buyers, the sellers, and the registry are separate entities. That splits the problem in two: how the parties talk to each other, and where each party actually runs its side of the transaction. The open protocols answer the first. They are the wire between parties, carrying discovery, negotiation, and settlement, and they stop there. Where an agent runs, holds its state, proves its identity, and stays governed is the platform's job. So each party has a self-contained application, built on Databricks Apps, that owns its state, its identity, and the models it runs, and meets the others only over the protocols. The sections that follow take these pieces one at a time and show why each belongs there.
Under the hood, the buyer agent is a “crew”, or group, of specialist agents built using CrewAI. The crew works hierarchically across three levels, with the Level 1 agent able to delegate tasks to Level 2 agents and so on. These agents include a Level 1 Portfolio Manager that sets strategy and splits the budget, Level 2 Channel Specialists that specialize in shopping a specific medium, and Level 3 tactical workers that plan audiences and execute the buy. They run on Databricks Foundation Model APIs and are configured to use Claude models depending on the task complexity. Using Databricks Unity AI Gateway to run these agents makes it easy to change the LLM powering each agent without changing anything else.
Agents need two things from their data: context to act on, and a place to record what they do. Our buyer reads its briefs, each seller reads its inventory catalog and pricing rules, and they write back every order booked. That's classic OLTP, so we put it on Lakebase, Databricks' serverless Postgres, running right next to the lakehouse. The agents read and write state quickly with transactional guarantees, and because it's Postgres, the seller components drop straight onto it with no bespoke data layer. And because Lakebase is serverless, it autoscales in milliseconds to meet bursty demand. Agents don't arrive at a steady rate, and buyers can fan out to many sellers at once without pre-provisioning capacity.
Right now this demo uses Lakebase alone. In the real world, Lakebase sits between two governed Unity Catalog boundaries. On the way in, data is hydrated from Unity Catalog tables into Lakebase — a seller's inventory and its ML-model-driven pricing, a buyer's campaign briefs and audience definitions. On the way out, the transactional state the agents produce — who bought what, at what price — is synced back to your reporting environment. Both directions run on Databricks managed pipelines instead of brittle, hand-written ETL. That makes it a governed round trip: Unity Catalog automatically tracks the lineage of every hydrate and sync, so you can always trace what data moved where. The lakehouse stays the source of truth on both ends, and Lakebase is the operational, hot-serving layer where the agents transact.
The apps authenticate with each other using OAuth — the mechanism that establishes and verifies who each one claims to be — and a registry assigns each buyer a trust tier. That tier decides what a buyer can even see: an unknown, public buyer gets only price ranges and can't transact; a trusted, verified buyer gets exact prices and can book. Flip the buyer's trust and the same campaign that was locked to price ranges can now be booked. On Databricks, that identity story is native to how Apps and data access already work.Where the IAB reference SDK reaches for API keys, we simply use the platform's built-in service principals and OAuth to authenticate using today's best practice,with nothing extra to build.
The agent crews are wired for MLflow tracing, which is easily implemented via a one-line CrewAI autolog hook. This allows us to capture the reasoning steps, the tool calls, the prices read, and the book-or-pass decision of every agent run. We kept it optional for the demo, but this is exactly how you'd want to productionize, debug, tune, and trust an autonomous system when it comes to budget controls.
Let’s follow a complete run on one campaign. We start by submitting the advertiser's brief, which in this scenario is a Q3 Brand Launch, with a budget of $200,000 across the CTV and Linear TV media types, and a $38 CPM (Cost Per Mille) ceiling. This brief is sent to the buyer app, and the agent crew kicks off the buying process.
1. Plan the budget: The Portfolio Manager reads the brief and splits the spend across channels, allocating $120k to CTV and $80k to Linear.
2. Translate the audience: A specialist maps the brief's plain-language audiences to standard segments, validated against the IAB Tech Lab Audience Taxonomy: "sports fans" maps to “Sports Enthusiasts”, and "auto intenders" maps to “Auto Intenders”.
**3. Discover the sellers: **The buyer discovers publishers in the registry: Seller A (CTV) and Seller B (Linear), which confirms the buyer's identity and stamps its access tier.
4. Price it: A Channel Specialist for each channel shops its seller over MCP, matches the audience segment to an available product, and reads the authoritative price.
5. Book or pass: One rule: book if the price is at or under the $38 ceiling and the product audience matches; otherwise, walk away.
What we've shown here is the middle of the trade: the agents that transact. But the same platform is the best place to build the left and right sides too: the buyer's brief creation, the ML models that set a seller's package pricing, the models and dashboards used to estimate revenue and expenditures. These are problems whose solutions depend on governed data and ML which both live natively on Databricks. Our team is committed to updating the repository, ensuring it evolves alongside the IAB Tech Lab as additional AAMP capabilities are released.
This system ships as a Databricks Automation Bundle accelerator. Clone the repo, point the Databricks CLI at your workspace, and run a single command:
Use this command to build and deploy the apps and the Lakebase instances, seed the data, and wire the buyer to the sellers through the registry. A few minutes later you have two live seller agents, a registry, and a buyer console, all transacting in your own workspace.
From there, make it yours. Swap in your own inventory, pricing rules, and audiences, or wire the Lakebase layer to your real catalog and models. Step into the trade as the buyer or the seller and watch how the agents react: change a price, flip a buyer's trust tier, add a seller, and see the negotiation play out. It's a working blueprint tailored for agentic media buying and selling.
Watch the 5-minute demo, then deploy the accelerator in your own workspace.
Subscribe to our blog and get the latest posts delivered to your inbox.