AdCP and Salesforce: Unifying Agent-to-Agent Commerce with Your CRM

The way most publishers and media companies manage advertising operations is completely broken.

You probably have a CRM holding your client relationships. You probably have an order management system (OMS) handling the actual inventory execution. And sitting right in the middle is a brittle, custom-built API layer held together by duct tape and blind faith.

Every time your sales team closes a deal, data has to jump across systems. Things break. Records duplicate. Revenue recognition turns into a forensic accounting exercise.

This assumes commerce happens somewhere else and the CRM is just a digital rolodex.

But that mindset is dead.

ADvendio’s foundational conviction destroys this legacy approach. The CRM is the commerce platform. It is not an adjacent system. Because ADvendio is built natively on Salesforce, there is no separate database. There is no external API layer for core data. There is absolutely zero middleware sitting between your ad-ops workflow and the master customer record.

And this is where the industry is aggressively heading. If you want to survive the next five years, your infrastructure must be ready for autonomous, machine-driven transactions.

This brings us to the core of the issue. By combining AdCP and Salesforce, ADvendio is actively transforming static customer relationship management into a live, agent-ready storefront.

AdCP and Salesforce: A Complete Architectural Shift

Think about the traditional ad-tech stack. It is bloated. Vendors love to sell you software that requires its own dedicated servers, its own data lakes, and its own proprietary security models.

Run away.

If a vendor tells you their software can be installed on your local server, that is not a feature. That is a massive liability. ADvendio explicitly positions its cloud-native, multi-tenant SaaS against these on-premise legacy ad-ops systems. Legacy systems are expensive to maintain, slow to extend, and notoriously poor in data quality. Multi-tenancy is the only way to scale without drowning in technical debt.

The combination of AdCP and Salesforce changes the entire game.

Instead of forcing your team to log into a third-party application to manage media campaigns, ADvendio pulls the entire ad-selling process directly into the native Salesforce OMS. When publishers realize they need both order management and CRM capabilities, they usually try to buy two different products and wire them together. ADvendio provides a vertical solution that is, fundamentally, a CRM first.

This native foundation sets the stage for the true co-pilot strategy. Salesforce provides the generic AI engine through Agentforce. ADvendio provides the expert driver. It supplies the domain-specific training manual that turns a generalist AI agent into a highly specialized media sales expert.

The Middleware Trap vs. The Stateless Gateway

Here is the reality of external integrations. They leak data. They create latency. They expose you to compliance risks.

Typical ad-tech integrations build their own external logic. They pull your commercial data out of your secure CRM, store it in a third-party cloud, process it, and push the results back. This creates a persistent vulnerability. It also means you no longer have a single source of truth.

ADvendio’s architecture fundamentally rejects this model.

The CRM acts as the single source of truth for all commercial data. The ADvendio Gateway handles the external connectivity, but it is entirely stateless. All data passing through the Gateway is volatile. It exists in RAM-only transit. There is absolutely zero persistent storage in this intermediary layer.

This means every single agent-to-agent transaction lands directly inside your secure Salesforce records. It never sits in some third-party purgatory waiting to be synced.

This stateless approach scales massively. Through strategic integration partners like elastic.io, this middleware architecture routinely handles up to 4 million transactions per minute. You get enterprise-grade volume without sacrificing the integrity of your CRM database.

AdCP: Turning Your CRM Into an Agent-Ready Storefront

We need to talk about AdCP.

The Ad Context Protocol (AdCP) versions 3.0 and 3.1 are built on the Model Context Protocol (MCP). This is not just another API. This is the exact language that allows an ADvendio Salesforce org to operate as a live storefront. External AI buyer agents can transact against this storefront using plain, natural language.

The industry is already moving toward autonomous media buying. We are seeing AI systems actively exploring thousands of potential adjustments across targeting and bidding without human intervention. The IAB Tech Lab is currently defining core Agentic Advertising Management Protocols to standardize this exact behavior for programmatic audiences.

AdCP bridges the gap between these external buyer agents and your internal Salesforce data.

Right now, there are six core AdCP tools running in production:

• get_products: Allows the buyer agent to discover available inventory.
• create_media_buy: Translates an agent’s intent into a tangible campaign booking.
• get_media_buys: Fetches existing campaign data.
• update_media_buy: Pushes live optimizations to an active campaign.
• get_media_buy_delivery: Tracks live pacing and status.
• get_account_financials: Pulls billing and revenue data.

When an external buyer agent—like Claude, Cursor, or a custom SDK—queries your inventory, it isn’t scraping a webpage. It is executing a natural language request that AdCP instantly translates into native Salesforce objects. Media Campaigns, Campaign Items, Ad Prices, and Accounts are generated and modified in real time.

A seller agent using this protocol can scale to over 100 items in a single asynchronous campaign generation. The catalog optimization engine easily supports up to 30,000 Ad Prices.

And here is the best part. When an external agent books a campaign, that booking doesn’t bypass your team. All AdCP bookings land in an “In Approval” status by default. They drop right into your publisher’s standard seller workflow inside Salesforce. Your human team maintains total control.

Zero-Trust Security for Agent-to-Agent Commerce

Security is the elephant in the room when we talk about AI agents.

If an external AI is querying your inventory and pricing, how do you stop it from seeing confidential client data? How do you prevent a buyer agent from accessing your internal margins?

Most ad-tech platforms try to build a custom “AdCP-layer filter” to hide sensitive fields. This is dangerous. Custom security logic breaks.

AdCP and Salesforce solve this through strict inheritance. Agent-to-agent commerce must inherit your existing CRM security. It cannot bypass it. The AdCP MCP Server deliberately executes every single tool call in standard Salesforce user mode.

Think about what that actually means.

Every single AdCP API token is bound to one specific Salesforce user. The buyer agent can only see what that specific user’s profile allows. Sharing rules apply. Profile permissions apply. Record access limits apply. Field-level security applies. There is a strict 1:1 mapping between the external agent and the Salesforce user.

If a field is hidden from the assigned Salesforce user profile, it is completely invisible to the AI agent. You don’t have to build new security rules for AI. You just leverage the exact same enterprise-grade security architecture you already trust to run your business.

Automating the Bureaucracy: The AdCP Accounts Protocol

Onboarding new advertisers is usually a manual, soul-crushing process. Sales reps waste hours keying in agency details, tax IDs, and billing addresses.

The newest AdSuite release (version 1.16) eliminates this completely through the AdCP Accounts Protocol.

External buyer agents can now submit advertiser and agency account requests directly through the protocol. These requests do not instantly overwrite your CRM data. Instead, they land securely in a designated review queue within Salesforce. Your finance or operations team reviews the request.

Once they click approve, the accounts are provisioned automatically. The system automatically tags the Account Source as “External Agent.” No manual data entry. No duplicate records. No human error. Just a clean, automated pipeline from an external AI directly into your verified Salesforce database.

Absolute Price Transparency on the Salesforce Record

Pricing in ad-ops is notoriously opaque. Agencies apply markups, publishers apply discounts, and by the time the campaign runs, nobody knows what the actual net-net revenue is without checking three different spreadsheets.

When you bring AdCP and Salesforce together, the CRM record itself becomes the absolute single source of commercial truth.

Every package booked through the AdCP protocol returns ADvendio’s exhaustive price breakdown directly into the Salesforce record. Both the buyer agent and your internal team see the exact same math.

The waterfall is meticulously documented:

1. List Price: The base catalog rate.
2. Surcharges: Any targeting or premium fees added.
3. Gross Price: The subtotal before negotiations.
4. Discounts: Negotiated rate reductions.
5. Net Price: The cost to the buyer.
6. Agency Earnings: The agency’s cut.
7. Net-Net Price: Your actual realized revenue.

It also factors in applied price rules and automated commitment discounts. There are no hidden fees sitting in a disconnected ad server. The financial reality of every campaign lives directly on the Media Campaign object in Salesforce.

The Hub-and-Spoke Reality: Retail Media and New Channels

Let’s look at how this architecture plays out in the real world.

The framework is a classic hub-and-spoke model. The CRM acts as the central hub. External platforms—whether they are ad servers, DSPs, social networks, or retail media engines—act as the spokes connected via the stateless Gateway. AdCP is simply another spoke on this wheel, one that speaks the language of “agents” instead of traditional APIs.

Take retail media, for example. We know that retailers sit on troves of valuable first-party consumer data. They need to monetize this data aggressively.

Customer A is a massive retailer selling prime ad inventory across their website and in-store media. But they have a dual challenge. They need to sell their own ad space while simultaneously managing their own massive media buying operations. They are using ADvendio as their native Salesforce OMS to power this complex retail media solutions ecosystem.

Then you have Topsort. Retail media marketplaces running on Topsort need financial alignment. They need campaign visibility without forcing their teams to log out of their primary systems. ADvendio solves this by acting as the central OMS. In Phase I of the Topsort integration, ADvendio delivers financial alignment, read-only campaign visibility, and deep performance reporting directly inside Salesforce.

Phase II goes even further. ADvendio will transition from providing read-only visibility to becoming the actual system of campaign creation. Campaigns, audience targeting, and real-time bid adjustments will all be managed directly from within Salesforce and pushed to Topsort.

This same template applies to new-generation ad servers.

Publishers cannot afford to wait six months for custom, one-off API builds every time they want to test a new channel. Kevel is dominating the custom retail tech space. Vistar Media is revolutionizing digital out-of-home (DOOH). ADvendio integrates with both of them using established, standardized patterns.

The Kevel integration (version 2.182 and up) and the Vistar Media integration (version 2.180 and up) are both generally available right now. They enable automated trafficking, real-time delivery reporting, and direct revenue recognition across omnichannel advertising strategies, all executed natively from within the ADvendio and Salesforce environment.

Where AdCP and Salesforce Are Headed Next

This is not a theoretical roadmap. This is active development.

Beyond the current seller-side pilots, ADvendio is building the ADvendio Buyer Agent. Soon, the system will act on the buy-side. It will autonomously discover and book inventory across other AdCP-compatible publishers, as well as social and programmatic channels via the customer’s own DSP.

We are also looking at a massive leap forward in true machine learning.

While the current Generative AI suite handles language and workflow, the future relies on predictive AI. By converging with Salesforce Data Cloud, ADvendio is driving advanced predictive capabilities. We are talking about highly accurate revenue forecasting, proactive client churn prediction, identity resolution, and zero-copy BigQuery federation.

And we cannot ignore autonomous agents. The goal is to build AI that performs complex tasks without explicit human instruction. Imagine an autonomous system that can generate a comprehensive, highly targeted media proposal simply by reading an uploaded client brief.

To support this, ADvendio is heavily investing in template flows. The new DML Hook template flows introduced in version 1.16 allow customers to inject custom business rules into agent-created records without writing a single line of code. It is a massive step toward fully customer-configurable agent behavior natively inside Salesforce.

The era of disjointed ad-tech is over. If you want to scale revenue, protect your data, and prepare for the agent-to-agent economy, you have to centralize your operations. The combination of AdCP and Salesforce isn’t just an integration. It is the new operating system for media commerce.