automation

How SSPs Can Prepare Their Infrastructure for Agent-to-Agent Programmatic Transactions

A strategic guide for SSPs preparing for the agentic advertising era, covering protocols, APIs, and infrastructure readiness.

How SSPs Can Prepare Their Infrastructure for Agent-to-Agent Programmatic Transactions

How SSPs Can Prepare Their Infrastructure for Agent-to-Agent Programmatic Transactions

The programmatic advertising ecosystem stands at an inflection point. After years of incremental optimization through machine learning and automation, we are now witnessing the emergence of something fundamentally different: autonomous AI agents that can negotiate, execute, and optimize advertising transactions without continuous human intervention. For Supply-Side Platforms (SSPs), this shift represents both an existential challenge and a generational opportunity. The platforms that prepare their infrastructure now will define the next decade of programmatic advertising. Those that wait risk becoming legacy systems in an agentic world. This guide provides a comprehensive roadmap for SSP technical leaders, product managers, and strategists who recognize that the future of programmatic is not just automated, but truly autonomous.

The Agentic Transformation: Understanding What's Coming

Before diving into infrastructure requirements, it is essential to understand precisely what we mean by "agent-to-agent" transactions and why they differ so fundamentally from current programmatic workflows.

From Automation to Autonomy

Today's programmatic advertising, despite its sophistication, remains fundamentally reactive. DSPs and SSPs exchange bid requests and responses at scale, but the logic governing these exchanges is deterministic. Rules are set by humans. Optimization happens within predefined parameters. When something goes wrong, human intervention is required. Agent-to-agent transactions represent a paradigm shift. In this model, AI agents operating on behalf of buyers and sellers can:

  • Negotiate deal terms dynamically: Rather than accepting or rejecting fixed parameters, agents can propose counter-offers, suggest alternative inventory packages, and find creative solutions to meet campaign objectives
  • Learn and adapt continuously: Unlike rule-based systems, AI agents improve their performance based on outcomes, developing increasingly sophisticated strategies over time
  • Communicate in natural language: Emerging protocols enable agents to exchange structured information through conversational interfaces, dramatically reducing integration complexity
  • Operate asynchronously: While traditional RTB operates in milliseconds, agentic transactions can span seconds, hours, or even days, accommodating human-in-the-loop approvals and complex negotiations

As Emma Newman, CRO EMEA at PubMatic, noted in recent industry commentary: "The shift towards agentic systems represents programmatic's most exciting transformation yet. Autonomous buyer and publisher agents, supported by intelligent intermediaries, can negotiate, optimise, and act on behalf of their human counterparts" :cite[duj].

The Protocol Landscape

Several emerging standards are shaping how agent-to-agent communication will work in advertising: Model Context Protocol (MCP): Developed by Anthropic and now widely adopted, MCP provides the foundational layer for connecting AI systems to external data sources and tools. Think of it as the TCP/IP of agentic AI, establishing basic rules for how agents discover and interact with external resources :cite[d32]. Ad Context Protocol (AdCP): Built on MCP, AdCP is specifically designed for advertising workflows. It standardizes how AI agents exchange information about audiences, inventory, and campaign objectives. The protocol is being developed by an industry consortium including PubMatic, Scope3, Yahoo, and others :cite[cu0]. Agent-to-Agent Protocol (A2A): Complementing MCP, A2A establishes frameworks for direct communication between AI agents, enabling the kind of negotiation and collaboration that distinguishes agentic transactions from traditional automation :cite[d32]. These protocols are not theoretical. PubMatic and agency Butler/Till recently executed what they claim is the first "fully agentic" media buy for beverage brand Clubtails, using AdCP to enable AI agents to plan and execute a connected TV campaign :cite[drk].

Core Infrastructure Requirements for SSPs

Preparing for agent-to-agent transactions requires fundamental changes to how SSPs architect their systems. The following sections outline the critical infrastructure components.

1. Protocol-Native API Architecture

The most immediate requirement is developing APIs that speak the language of AI agents. This goes far beyond simply documenting existing endpoints. Implementing MCP Server Capabilities SSPs should prioritize implementing MCP server functionality that exposes their core capabilities to AI agents. PubMatic has published open-source specifications for deal management via MCP, providing a template for how this can work :cite[d32]. A basic MCP server implementation for an SSP might expose the following capabilities:

# Example MCP Server Tool Registration for SSP
from mcp import Server, Tool
server = Server("ssp-inventory-server")
@server.tool()
async def get_available_inventory(
audience_criteria: str,
content_categories: list[str],
geography: list[str],
date_range: dict
) -> dict:
"""
Discover available inventory matching specified criteria.
Accepts natural language audience descriptions.
"""
# Translate natural language to internal targeting
targeting = await parse_audience_criteria(audience_criteria)
# Query inventory availability
inventory = await inventory_service.query(
targeting=targeting,
categories=content_categories,
geo=geography,
dates=date_range
)
return {
"available_impressions": inventory.total_impressions,
"estimated_cpm_range": inventory.cpm_range,
"matching_publishers": inventory.publisher_summary,
"targeting_confidence": inventory.match_score
}
@server.tool()
async def create_deal(
deal_parameters: dict,
approval_required: bool = True
) -> dict:
"""
Create a private marketplace deal with specified parameters.
Supports human-in-the-loop approval workflows.
"""
deal = await deal_service.create(
params=deal_parameters,
status="pending_approval" if approval_required else "active"
)
return {
"deal_id": deal.id,
"status": deal.status,
"approval_url": deal.approval_url if approval_required else None,
"estimated_delivery": deal.forecast
}

AdCP Integration Considerations AdCP provides a standardized schema for advertising-specific operations. SSPs implementing AdCP support should focus on these core task types :cite[ekh]:

  • get_products: Enable inventory discovery through natural language queries
  • create_media_buy: Support programmatic deal creation across multiple formats
  • get_media_buy_delivery: Provide real-time performance metrics in standardized formats
  • sync and update operations: Allow agents to modify active campaigns based on performance signals

The key architectural principle is designing for semantic interoperability. Your APIs should not just accept structured parameters but understand intent. When a buyer agent asks for "sports enthusiasts with high purchase intent," your system should be able to translate that into actionable targeting criteria.

2. Semantic Data Infrastructure

Agent-to-agent transactions depend on rich, well-structured data that AI systems can reason about. This requires rethinking how SSPs organize and expose their data assets. Inventory Taxonomy and Metadata Traditional inventory categorization often relies on IAB content taxonomies and basic metadata. For agentic systems, SSPs need to develop richer semantic representations:

{
"inventory_unit": {
"id": "pub_12345_slot_a",
"publisher": {
"domain": "example-news.com",
"trust_signals": {
"ads_txt_verified": true,
"sellers_json_listed": true,
"content_verification_score": 0.94
}
},
"content_context": {
"iab_categories": ["News", "Business"],
"semantic_topics": ["Technology", "AI", "Enterprise Software"],
"sentiment": "neutral",
"brand_safety_score": 0.91,
"attention_metrics": {
"avg_time_in_view": 12.3,
"scroll_depth_percentile": 78
}
},
"audience_signals": {
"demographic_indices": {
"income_high": 1.4,
"education_college_plus": 1.6
},
"behavioral_segments": ["tech_enthusiasts", "business_decision_makers"],
"intent_signals": ["software_evaluation", "vendor_research"]
},
"historical_performance": {
"avg_ctr": 0.0023,
"avg_viewability": 0.78,
"completion_rate_video": 0.67
}
}
}

This rich metadata enables buyer agents to make nuanced decisions and enables seller agents to package inventory more effectively. First-Party Data Activation The signals protocol within AdCP is specifically designed for first-party data integration. SSPs should develop infrastructure that allows publishers to:

  • Register available signals: Expose first-party audience data in privacy-compliant ways
  • Enable signal activation: Allow buyer agents to request specific signal overlays for campaigns
  • Support clean room integrations: Facilitate privacy-preserving data collaboration between buyers and sellers

3. Asynchronous Transaction Processing

One of the most significant architectural shifts for SSPs is moving from purely synchronous RTB processing to supporting asynchronous agentic workflows. Webhook-Based Communication Unlike RTB's millisecond response requirements, agentic transactions can span extended periods. SSPs need robust webhook infrastructure to handle:

# Example webhook handler for agentic deal updates
@app.route('/webhooks/deal-updates', methods=['POST'])
async def handle_deal_update():
payload = request.json
event_type = payload.get('event_type')
deal_id = payload.get('deal_id')
if event_type == 'buyer_counter_proposal':
# Handle negotiation from buyer agent
counter_terms = payload.get('proposed_terms')
await negotiation_service.evaluate_proposal(
deal_id=deal_id,
terms=counter_terms,
auto_accept_threshold=0.85  # Accept if within parameters
)
elif event_type == 'approval_received':
# Human approved the deal - activate
await deal_service.activate(deal_id)
await notify_buyer_agent(deal_id, status='active')
elif event_type == 'performance_feedback':
# Buyer agent providing outcome signals
feedback = payload.get('feedback')
await learning_service.ingest_feedback(
deal_id=deal_id,
performance_data=feedback
)
return {'status': 'processed'}

State Management for Long-Running Transactions Agentic negotiations can involve multiple rounds of back-and-forth communication. SSPs need state management systems that can:

  • Track conversation history: Maintain context across multiple agent interactions
  • Handle parallel negotiations: Support simultaneous discussions with multiple buyer agents
  • Implement timeout and escalation logic: Know when to escalate to human oversight
  • Support rollback and versioning: Allow negotiations to return to previous states if needed

4. Human-in-the-Loop Integration

Despite the "autonomous" nature of agentic systems, human oversight remains critical. As Ben Foster, COO at The Kite Factory, emphasized: "In order to accelerate the adoption of Agentic AI, businesses need to see operations less as a compliance function and more as a key growth lever with a huge scope for creativity" :cite[duj]. SSPs should architect their systems to support flexible human intervention: Approval Workflows

class ApprovalWorkflow:
def __init__(self, deal_id: str, approval_config: dict):
self.deal_id = deal_id
self.config = approval_config
async def evaluate_auto_approval(self, deal_terms: dict) -> bool:
"""
Determine if deal can be auto-approved based on parameters.
"""
checks = [
self._check_price_floor(deal_terms),
self._check_brand_safety(deal_terms),
self._check_inventory_availability(deal_terms),
self._check_buyer_reputation(deal_terms)
]
return all(await asyncio.gather(*checks))
async def request_human_approval(self, deal_terms: dict, reason: str):
"""
Route deal for human review with context.
"""
approval_request = {
'deal_id': self.deal_id,
'terms': deal_terms,
'requires_approval_reason': reason,
'ai_recommendation': await self._generate_recommendation(deal_terms),
'risk_assessment': await self._assess_risks(deal_terms)
}
await notification_service.send_approval_request(
recipients=self.config['approvers'],
request=approval_request
)

Audit Trail and Explainability Every agentic transaction should generate comprehensive audit trails that humans can review:

  • Decision logging: Record what information the agent considered and why it made specific choices
  • Conversation archives: Store complete interaction histories with buyer agents
  • Outcome tracking: Link decisions to their ultimate performance outcomes for continuous improvement

5. Security and Authentication for Agent Identities

As agents begin transacting on behalf of organizations, SSPs need robust systems for verifying agent identity and authorization. Agent Identity Verification The adagents.json concept, analogous to ads.txt for human-readable authorization, is emerging as a standard for declaring which agents are authorized to act on behalf of a domain :cite[ekh]:

{
"version": "1.0",
"publisher": "example-publisher.com",
"authorized_agents": [
{
"agent_id": "pubmatic-seller-agent-v2",
"provider": "pubmatic.com",
"capabilities": ["inventory_discovery", "deal_creation", "performance_reporting"],
"authorization_level": "full",
"valid_until": "2026-12-31"
},
{
"agent_id": "custom-yield-optimizer",
"provider": "internal",
"capabilities": ["floor_optimization", "header_bidding_config"],
"authorization_level": "limited",
"requires_approval": ["deal_creation"]
}
]
}

Capability-Based Access Control SSPs should implement fine-grained access control that limits what actions specific agents can perform:

class AgentAuthorizationService:
async def verify_agent_request(
self,
agent_id: str,
requested_action: str,
resource: str
) -> AuthorizationResult:
# Verify agent identity
agent = await self.agent_registry.get(agent_id)
if not agent or not agent.is_valid():
return AuthorizationResult(allowed=False, reason="Unknown or expired agent")
# Check capability for requested action
if requested_action not in agent.capabilities:
return AuthorizationResult(
allowed=False,
reason=f"Agent not authorized for {requested_action}"
)
# Check resource-specific permissions
if not await self._check_resource_access(agent, resource):
return AuthorizationResult(
allowed=False,
reason="Agent not authorized for this resource"
)
# Check if action requires human approval
if requested_action in agent.requires_approval:
return AuthorizationResult(
allowed=True,
requires_approval=True,
approval_type=agent.approval_config[requested_action]
)
return AuthorizationResult(allowed=True)

Operational Readiness: Beyond Technology

Infrastructure preparation extends beyond technical architecture. SSPs must also prepare their organizations and operations for the agentic era.

Developing Seller Agent Capabilities

The most forward-thinking SSPs are not just preparing to receive requests from buyer agents but developing their own seller agents that can proactively:

  • Package inventory intelligently: Combine inventory across publishers to meet specific buyer needs
  • Negotiate deal terms: Counter-propose when initial offers do not meet publisher requirements
  • Optimize in real-time: Adjust pricing and allocation based on market conditions
  • Provide proactive recommendations: Suggest opportunities to buyer agents based on inventory availability and performance history

As Amir Sharer, CEO of BRAVE, observed: "The platforms that succeed will treat agents not as automation, but as transparent collaborators that optimise for outcomes without obscuring how decisions are made" :cite[duj].

Training and Change Management

The shift to agentic operations requires new skills across your organization:

  • Technical teams: Need expertise in AI/ML operations, prompt engineering, and agentic system design
  • Account management: Must understand how to configure and oversee agent behavior on behalf of publishers
  • Product teams: Need to think in terms of agent experiences, not just human interfaces
  • Compliance and legal: Must develop frameworks for agent accountability and liability

Publisher Education and Enablement

Your publisher partners will have questions and concerns about agentic transactions. Proactive education should cover:

  • How agent transactions differ from traditional programmatic: Set appropriate expectations
  • Control and oversight options: Demonstrate the human-in-the-loop capabilities
  • Performance implications: Share data on how agentic optimization affects yield
  • Privacy and brand safety: Address concerns about autonomous decision-making

Implementation Roadmap: A Phased Approach

Given the scope of changes required, SSPs should approach implementation strategically. Here is a suggested phased approach:

Phase 1: Foundation (Months 1-3)

  • Assess current API architecture: Identify gaps between existing APIs and agent-friendly design
  • Implement basic MCP server: Start with read-only inventory discovery capabilities
  • Enhance data infrastructure: Begin enriching inventory metadata for semantic understanding
  • Establish monitoring: Deploy logging and analytics for agent interactions

Phase 2: Core Capabilities (Months 4-6)

  • Enable deal creation via agents: Implement write operations with appropriate safeguards
  • Build human-in-the-loop workflows: Develop approval routing and escalation systems
  • Implement agent authentication: Deploy identity verification and authorization systems
  • Launch pilot program: Partner with select DSPs to test agent-to-agent workflows

Phase 3: Advanced Features (Months 7-12)

  • Develop seller agent capabilities: Build proactive inventory packaging and negotiation features
  • Enable asynchronous negotiations: Support multi-round deal discussions
  • Integrate performance feedback loops: Allow agents to learn from campaign outcomes
  • Expand publisher participation: Roll out agent capabilities across your publisher base

Phase 4: Optimization and Scale (Year 2+)

  • Implement advanced learning systems: Deploy AI models that improve agent performance over time
  • Cross-channel integration: Extend agent capabilities across display, video, CTV, and mobile
  • Ecosystem partnerships: Deepen integrations with DSP agents and emerging agentic platforms
  • Continuous protocol evolution: Participate in standards development and implement new capabilities

Challenges and Considerations

As SSPs prepare for the agentic era, several challenges warrant careful consideration:

Sustainability and Compute Costs

AI agents, particularly those powered by large language models, require significant computational resources. As Matthew Beck, VP Strategy & Partnerships at Nano Interactive, noted: "The rise of GenAI, combined with a lack of commercial models for training LLMs, will reduce the supply of high-quality, human-written content... This will inevitably drive up CPMs, pushing more spend into walled gardens" :cite[duj]. SSPs should carefully model the economics of agent operations and develop pricing strategies that account for increased infrastructure costs.

Protocol Fragmentation Risk

While AdCP, MCP, and A2A are emerging as leading standards, the risk of fragmentation remains. As Simon Kvist, CEO of Adnami, observed: "The real question is which win and who ultimately owns and drives them. In many ways, owning the protocol is the tech equivalent of owning the narrative" :cite[duj]. SSPs should participate actively in standards development while designing flexible architectures that can adapt to protocol evolution.

Trust and Transparency

The programmatic ecosystem already struggles with transparency issues. Agent-to-agent transactions must not exacerbate this problem. As the Digiday analysis of AdCP noted: "If widely adopted, AdCP could create a layer of machine transparency, making the mechanics of agentic transactions observable and verifiable by both parties" :cite[cu0]. SSPs should prioritize audit trails, explainability, and transparency in their agent implementations.

Regulatory Considerations

Autonomous AI systems are attracting increasing regulatory attention globally. SSPs should:

  • Monitor regulatory developments: Stay informed about AI governance requirements in key markets
  • Maintain human accountability: Ensure clear lines of responsibility for agent decisions
  • Document compliance: Maintain records demonstrating appropriate oversight and control

Conclusion: The Imperative of Preparation

The transition to agent-to-agent programmatic transactions is not a question of if, but when. The first agentic campaigns are already running. The protocols are being standardized. The infrastructure patterns are emerging. For SSPs, the strategic imperative is clear. As Jochen Schlosser, CTO at Adform, summarized: "Agentic workflows will enhance rather than replace programmatic advertising. These operate as an intelligence layer that accelerates planning and decision-making, while the transaction layer continues to rely on ML-based engines optimised for millisecond latency" :cite[duj]. The SSPs that invest now in protocol-native APIs, semantic data infrastructure, asynchronous processing capabilities, human-in-the-loop integration, and robust agent authentication will be positioned to thrive in the agentic era. Those that wait risk finding themselves unable to participate in the most sophisticated and valuable advertising transactions of the future. The programmatic ecosystem has always thrived on standardization. OpenRTB enabled the real-time bidding revolution. Header bidding transformed publisher yield optimization. Now, AdCP and related protocols are laying the foundation for the next transformation. The question for SSP leaders is simple: Will your platform be ready when buyer agents come calling?

Red Volcano specializes in publisher research and intelligence tools for the supply side of ad tech, helping SSPs, publishers, and ad networks discover opportunities and optimize their programmatic operations across web, app, and CTV environments.

Research References

  • ExchangeWire: "AI and Programmatic: The Agentic Age?" - https://www.exchangewire.com/blog/2025/12/09/ai-and-programmatic-the-agentic-age/ - Accessed January 2026
  • Digiday: "WTF is Ad Context Protocol (AdCP)?" - https://digiday.com/media-buying/wtf-ad-context-protocol/ - Accessed January 2026
  • Ad Age: "How PubMatic AI agents planned a programmatic CTV media buy" - https://adage.com/technology/ai/aa-agentic-ad-tech-pubmatic-butler-till/ - Accessed January 2026
  • PubMatic: "Defining the Future of Programmatic Collaboration" - https://pubmatic.com/blog/defining-the-future-of-programmatic-collaboration-charting-the-course-for-agent-to-agent-communication/ - Accessed January 2026
  • AdCP Official Site: https://adcontextprotocol.org/ - Accessed January 2026