Auction and Scoring

Learn how AIP auctions rank bids and select the most relevant recommendation for each user intent.

Auction and Scoring

AIP runs a short timed auction. When a platform sends a PlatformRequest, the operator tags it into category pools, derives a ContextRequest, and sends it only to Brand Agents subscribed to those pools. Delivery happens through a pub/sub system.

Agents have about 30–70 ms to send a signed bid. When the window closes, the Operator scores all bids (CPA first, then CPC, then CPX) and returns the winner. If no one responds in time, it returns no_bid.

The model avoids blasting every bidder, keeps latency low, and ensures only relevant agents compete.

1. TL;DR

AIP evaluates all eligible bids and returns the offer with the highest protocol-defined score.

2. Why It Matters

AIP enables AI systems to monetize intent responsibly.
Auctions prioritize relevance, quality, and economic value, creating recommendations that feel useful, aligned, and trustworthy.

This ensures:

• AI experiences remain user-centric
• Brands compete on merit and integrity
• Platforms gain a predictable monetization layer

3. How an Auction Works

Every user intent triggers a micro-auction. The sequence is:

1. Intent Enters the System

An AI platform submits a PlatformRequest describing the user’s query or action.

2. Bid Requests Are Issued

The Operator classifies the request into category pools, derives a ContextRequest, and uses publish/subscribe transport to deliver it only to Brand Agents subscribed to those pools.

3. Bids Are Returned

During the 30–70 ms auction window, each Brand Agent sends a signed POST /aip/bid-response payload with:

• an offer
• a bid price
• necessary metadata

4. Scoring Pipeline Evaluates Bids

The Operator runs its scoring model and produces a ranking.

5. A Single Winner Is Returned

The Operator sends the AuctionResult (or no_bid when no responses arrive in time) and serve_token back to the Platform.

4. Scoring Model

AIP scoring evaluates each bid using three core signals:

Value

Economic strength of the bid relative to the current intent.

Relevance

Alignment between the offer and the user’s query, conversation, or task context.

Quality

Trust, integrity, and historical performance signals from the Brand Agent’s verified events.

The Operator applies these pillars consistently for all bids, producing a deterministic score for each candidate.
The highest-scoring offer becomes the result of the auction.

5. AuctionResult

{
  "auction_id": "auc_981",
  "serve_token": "stk_abcxyz123",
  "winner": {
    "brand_agent_id": "ba_451",
    "preferred_unit": "CPA",
    "reserved_amount_cents": 500
  },
  "render": {
    "label": "[Ad]",
    "title": "Scale your CRM",
    "body": "Built for founders.",
    "cta": "Try for free",
    "url": "https://admesh.click/stk_abcxyz123"
  },
  "ttl_ms": 60000
}

For complete auction result schema, see: Auction Result Schema

6. Transparency and Verification

Every exchange in the auction cycle is logged as verifiable artifacts:

• signed ContextRequest
• signed BidResponse
• signed AuctionResult
• timestamps and nonces
• protocol version identifiers

7. Example Flow

User asks: “Best AI note-taking tools.”

1. A ContextRequest is issued.
2. The Operator distributes it to eligible Brand Agents.
3. Agents return bids.
4. The scoring pipeline ranks them.
5. The Platform receives a single recommendation and a serve_token.
6. Exposure and click events connect cleanly to the same attribution chain.

8. Guarantees

AIP ensures:

• consistent evaluation across all Brand Agents
• deterministic outcomes for identical inputs
• complete verifiability via signed artifacts
• unified attribution through the serve_token
• scalable real-time performance

Summary

AIP auctions transform user intent into ranked recommendations through a structured, deterministic evaluation system. The protocol harmonizes how Platforms monetize intent, how Brand Agents compete, and how Operators deliver transparent, reproducible outcomes.