Bid payloads, and - in delegate mode - accept session handoffs to execute real tasks.
A Brand Agent can be rule-based, ML-driven, or fully autonomous. AIP does not prescribe how it is built, only how it must speak to the protocol.
How operators and brand agents work together
High-level flow
- A Platform sends a PlatformRequest containing user intent to the Operator.
- The Operator evaluates participation eligibility and derives a ContextRequest.
- The Operator publishes the ContextRequest to subscribed Brand Agents.
- Brand Agents evaluate the ContextRequest and decide whether to participate.
- Brand Agents submit a bid to the Operator within the auction window.
- The Operator evaluates the auction outcome and determines the interaction mode.
- In recommend mode: the brand’s content is integrated into the AI response.
- In delegate mode: the brand agent receives a session handoff and executes a task.
- Verified events are reported and settled via the Operator.
Privacy-first context model
AIP separates intent capture from participation decisions to protect user privacy.- Platforms send PlatformRequests containing full interaction context to Operators.
- Operators derive a ContextRequest by removing sensitive or identifying data.
- Brand Agents receive only the ContextRequest.
Auction window and timing
AIP uses a time-bounded auction window to ensure low latency and predictable outcomes.- The auction window is determined by the platform’s
latency_budget_ms - The Operator computes the available response window by subtracting operator overhead
- Brand Agents must submit responses before the window expires
- Late responses are ignored and do not participate in the auction or settlement
1. What brand agents do
A Brand Agent:- Receives ContextRequests from an AIP Operator
- Evaluates anonymized user intent
- Decides whether to participate
- Returns a structured response
- Participates in real-time auctions
- Supports recommend mode (content contribution) and/or delegate mode (task execution)
- Receives verified lifecycle event callbacks
- Optimizes spend based on Operator settlement records
- SaaS or software companies
- E-commerce brands
- Mobile apps
- Marketplaces
- Agencies
- AI-native service providers
- Third-party autonomous agents
2. Normative responsibilities
Brand Agents MUST
- Expose a stable HTTP endpoint or supported transport
- Respond to ContextRequests within the Operator auction window
- Return one valid
Bidper ContextRequest - Include at least one valid pricing field in
pricing(cpx_micros,cpc_micros, orcpa_micros) - Provide a valid
recommendation.creative_inputpayload - Include required targeting, budget, and render metadata
- Respect the AIP event lifecycle: task_completed overrides interaction_started, which overrides exposure_shown
- Verify serve tokens in event callbacks
- Maintain spend accuracy using Operator settlement records
Brand Agents MUST NOT
- Submit malformed or incomplete response payloads
- Return responses without pricing
- Manipulate or forge serve tokens
- Generate artificial events or simulated traffic
- Submit multiple responses for a single ContextRequest
Brand Agents MAY
- Use any internal logic, including rules, heuristics, ML, LTV models, or autonomous agents
- Dynamically adjust pricing based on performance
- Decline to participate by not submitting a
Bid - Use contextual embeddings, RAG, or classifier models
- Implement their own budget and outcome controls
- Support one or both interaction modes (recommend and delegate)
3. What brand agents receive
Brand Agents do not receive PlatformRequests. Brand Agents receive a ContextRequest - a privacy-preserving, operator-derived representation of user intent used solely for participation decisions.Privacy guarantees
A ContextRequest does not include:- Raw user queries
- Conversation history or message transcripts
- User identifiers (user_id, account IDs, device IDs)
What brand agents do receive
A ContextRequest may include:- Upstream
message_idfor per-turn traceability - Intent summary or classification
- Decision phase (awareness, research, consideration, decision, action, post_purchase, support)
- Vertical or category signals
- Geographic or market region (coarse-grained)
- Operator-defined metadata and policy constraints
- Timing and auction parameters
4. Brand agent bid
Brand Agents submitBid payloads to the Operator within the auction window.
Each bid:
- Must be submitted within the active auction window
- Is evaluated only if received before the auction window closes
- Is associated with a single ContextRequest
| Field | Required | Description |
|---|---|---|
bid_id | Yes | Unique identifier for this bid |
brand_agent_id | Yes | Identifier of the Brand Agent placing the bid |
context_id | Yes | ID of the ContextRequest being bid on |
wallet_id | Yes | Wallet to debit if the bid wins |
targeting | Yes | Applicability constraints for the bid |
pricing | Yes | Billing fields in micros |
budget | Yes | Spend caps and pacing controls |
recommendation.creative_input | Yes | Structured content to render if selected |
declared_relevance | Yes | Brand-declared relevance score (0.0-1.0) |
supported_opportunities | Yes | Opportunity types the bid supports |
preferred_format | Yes | Preferred render format |
format_constraints | Yes | Rendering and ranking hints |
valid_until | Yes | RFC 3339 expiry timestamp for the bid |
timestamp | Yes | RFC 3339 creation timestamp |
delegation | No | Delegation capability declaration |
pricing.cpx_micros, pricing.cpc_micros, pricing.cpe_micros, or pricing.cpa_micros MUST be included for a valid bid.
The canonical bid contract is the Bid schema. Narrative examples and implementation guidance should follow that schema directly.
5. Participation in recommend mode
In recommend mode, the brand agent contributes content that is integrated into the AI’s response:- Provide creative content (short description, value propositions, CTA)
- Populate
recommendation.creative_inputwith the structured content used to render the recommendation - Content is rendered by the platform using the operator’s format
- No session transfer occurs
- Events tracked:
exposure_shown, optionallyinteraction_started, optionallytask_completed
6. Participation in delegate mode
In delegate mode, the brand agent receives a session handoff and executes a task:Brand agents that support delegation MUST:
- Accept session initiation from the Operator
- Respect context scope boundaries at handoff - only use operator-provided scoped context for session initiation and task execution
- Provide a functional experience that completes the intended task
- Declare delegation capability in the optional
delegationblock of the bid when applicable - Emit delegated-session activity signals while the delegated session remains active
- Fire
task_completedwhen the outcome is verified - Treat new user-provided session data as session-bound by default
- Handle session timeouts and errors gracefully
What the brand agent receives at session initiation:
session_id- the delegation session identifiercontext_scope- an array defining what context is shared (e.g.,["intent", "constraints"])- Intent and constraint data as defined by the scope
- The serve_token for event tracking
What the brand agent never receives:
- Raw user queries or conversation transcripts
- User identifiers
- Other agents’ participation data
7. Event callbacks
Once a Brand Agent is selected, the Operator sends event notifications tied to the serve token.Event types
| Event | Meaning |
|---|---|
exposure_shown | Commercial response was surfaced to the user |
interaction_started | User engaged with the recommendation |
delegation_started | Operator recorded delegated session start (delegate mode) |
delegation_activity | Platform or Brand Agent proved the delegated session was still active |
delegation_expired | Operator recorded delegated session expiry before completion |
task_completed | User completed the target action |
- Verify the serve token
- Confirm the event order is valid per the lifecycle
- Use callbacks for optimization and budget management
8. Settlement and spend
Operator responsibilities
Operators MUST:- Maintain accurate settlement ledgers
- Settle based on the event lifecycle (highest event wins)
- Expose settlement records to Brand Agents
- Guarantee no double billing
Brand Agent responsibilities
Brand Agents MUST:- Track spend using Operator settlement records
- Manage budgets
- Ensure funding is available for participation
- Pause participation when caps are reached
- Adjust pricing dynamically using outcome targets
- Run ML pipelines that optimize by event type and interaction mode
9. Implementation guidance (non-normative)
A Brand Agent can be implemented in any technology stack.Simple rules engine
ML-driven agent
- Classify the intent
- Predict user value
- Compute an optimal price
- Enforce margin and budget constraints
- Decide whether to support delegation for this request
Fully autonomous agent
- Runs continuously
- Learns from verified outcomes
- Adjusts pricing in real time
- Optimizes cross-operator performance
- Dynamically enables/disables delegation support based on conversion data
10. Summary
Brand Agents are commercial agents that:- Receive intent context
- Evaluate relevance
- Submit
Bidpayloads - Participate in real-time auctions
- Support recommend mode, delegate mode, or both
- Receive lifecycle event callbacks
- Manage budgets and performance
- Fair auction behavior
- Transparent outcome settlement
- Consistent interaction across Operators
- Interoperability between commercial agents
- Clear separation between recommendation and task execution