How AI Agents Can Verify Seller Policies Before Making Autonomous Purchases

Andy Smith — Wed, 25 Feb 2026 19:31:14 +0000

The agentic commerce stack has payment rails, checkout protocols, and agent identity verification. It's missing one thing: seller trust.

The Gap Nobody Talks About

Over the past six months, the infrastructure for AI agent commerce has come together fast.

Visa's Trusted Agent Protocol (TAP) went live in October 2025, giving agents cryptographic identity so merchants know they're dealing with a legitimate AI buyer. OpenAI's Agentic Commerce Protocol (ACP), built with Stripe, launched in September 2025 and is now live for all US ChatGPT users as of February 2026. Google's Universal Commerce Protocol (UCP) launched at NRF in January 2026 with 20+ major retail partners including Walmart, Target, and Wayfair.

The stack looks like this:

Agent Identity:    Visa TAP  (proves the agent is legit)
Checkout:          ACP / UCP (handles the transaction)
Payment:           Stripe, x402, USDC micropayments
Fraud:             Payment processors

There's no layer that answers: is this seller's return policy, shipping policy, or terms of service actually consumer friendly?

An agent using ACP to buy a $400 item from a merchant you've never heard of will complete that checkout smoothly. What it won't know, unless it reads the fine print itself, is whether that merchant charges a 25% restocking fee, ships from overseas with no tracking, buries binding arbitration in their terms of service, or as recently found in the Oct 2025 crypto crash, there's a clawback policy.

That's the gap PolicyCheck fills.

What PolicyCheck Does

PolicyCheck is a pre purchase seller verification API for AI agents. Before an agent commits to a purchase, it calls PolicyCheck with the seller URL. The API returns a structured, machine readable risk assessment covering:

Return and refund policies (restocking fees, return windows, who pays return shipping)
Shipping policies (estimated delivery, tracking, international fulfillment)
Warranty and product protection terms
Legal risk signals (binding arbitration, class action waivers, liability caps)
Buyer protection score (0-100)
Risk score (0-10)
Signed flags with severity levels

The design principle is deliberate: PolicyCheck is an intelligence provider, not a gatekeeper. It returns facts and scores. The agent decides what to do with them. This is the same model Carfax uses for used cars - here's the vehicle history, you make the call.

The API

Signed Assessment Endpoint

POST https://policycheck.tools/api/v1/signed-assessment
Content-Type: application/json

{
  "seller_url": "https://6pm.com"
}

Response:

{
  "seller_url": "https://6pm.com",
  "domain": "6pm.com",
  "risk_score": 2.1,
  "grade": "A",
  "buyer_protection_score": 88,
  "flags": [
    {
      "id": "return_shipping_fee",
      "severity": "medium",
      "description": "Return shipping is at buyer's expense for standard returns"
    }
  ],
  "positives": [
    "365-day return window",
    "Free standard shipping on all orders",
    "Price match guarantee"
  ],
  "analysis_timestamp": "2026-02-25T10:30:00Z",
  "signature": "ed25519:base64_signature_here",
  "public_key_id": "policycheck-signing-key-2025"
}

Signature Verification

Every assessment is signed with Ed25519, using the same cryptographic standard as Visa TAP (RFC 9421 HTTP Message Signatures). Agents can verify assessments are genuine and haven't been tampered with:

POST https://policycheck.tools/api/v1/verify
Content-Type: application/json

{
  "assessment": { ...the full assessment object... },
  "signature": "ed25519:..."
}

Public key discovery follows the standard JWKS pattern:

GET https://policycheck.tools/.well-known/jwks.json

Integration Patterns

Pattern 1: Pre-Purchase Check in an ACP Flow

ACP handles the checkout. PolicyCheck handles the pre-checkout verification. An agent using ChatGPT's "Buy it in ChatGPT" feature can call PolicyCheck before initiating the ACP checkout flow:

async function purchaseWithVerification(sellerUrl, productDetails) {
  // Step 1: Verify seller before committing
  const assessment = await fetch('https://policycheck.tools/api/v1/signed-assessment', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ seller_url: sellerUrl })
  }).then(r => r.json());

  // Step 2: Apply agent's own thresholds
  if (assessment.risk_score > 6.0) {
    return { proceed: false, reason: 'Seller risk score too high', assessment };
  }

  if (assessment.flags.some(f => f.id === 'no_returns')) {
    return { proceed: false, reason: 'Seller does not accept returns', assessment };
  }

  // Step 3: Proceed with ACP checkout
  return initiateACPCheckout(productDetails);
}

Pattern 2: MCP Tool Integration

PolicyCheck is available as an MCP tool via npm. Add it to any MCP-compatible agent:

npm install -g policycheck-mcp

Configure in your MCP settings:

{
  "mcpServers": {
    "policycheck": {
      "command": "policycheck-mcp"
    }
  }
}

The agent can then call check_seller_policy as a native tool alongside web search, calendar access, or any other MCP tool.

Pattern 3: x402 Micropayment Integration

For autonomous agent transactions using x402 (HTTP 402 Payment Required), PolicyCheck supports USDC micropayments on Base mainnet. Agents with a crypto wallet can access the API without OAuth, API keys, or user intervention - the payment is part of the HTTP request itself.

This matters for fully autonomous agents that need to operate without human-managed credentials. The x402 pattern means an agent can:

Discover PolicyCheck via the x402 Bazaar (where it's currently listed #1)
Call the API with a USDC micropayment attached
Receive a signed assessment
Proceed or abort the purchase

No signup, no API key, no human in the loop.

Pattern 4: A2A Protocol

PolicyCheck exposes an A2A-compatible agent card at /.well-known/agent.json, allowing agent-to-agent discovery. An orchestrating agent can dynamically discover PolicyCheck's capabilities and route policy verification tasks to it without hardcoded integration.

How the Analysis Works

The analysis engine uses LLM-based policy parsing rather than simple keyword matching. This matters because policy language is intentionally vague and legally crafted.

Key design decisions:

Source aware severity weighting. A binding arbitration clause buried in a 50-page Terms of Service carries less practical weight than a prominently disclosed restocking fee in the Returns policy. The engine weights flags differently based on where in the seller's policy structure they appear.

Null scores for unanalyzable sites. If a site doesn't have accessible policies, the API returns null scores with an explicit status indicator rather than defaulting to a misleading perfect score. An agent that sees policy_status: "not_found" knows to treat the seller as unknown-risk.

Consumer-impact focus. The engine looks for clauses that affect the buying experience, not just legal compliance. A standard disclaimer that "prices may change" doesn't flag. A "we may substitute products of equal or greater value" clause does.

The Broader Architecture

PolicyCheck is deliberately protocol-agnostic. It works with:

Protocol	How PolicyCheck fits
Visa TAP	TAP proves agent identity to merchant; PolicyCheck proves seller safety to agent
OpenAI ACP	Pre-checkout verification before initiating ACP flow
Google UCP	Compatible via MCP and A2A interfaces
x402	Native micropayment support for autonomous agent transactions
Coinbase AgentKit	PR #948 pending -- adds PolicyCheck as native AgentKit tool
WebMCP / Chrome	PR #15 pending -- adds to navigator.modelContext API

TAP, ACP, and UCP handle different parts of the trust problem. TAP answers "is the agent legitimate?" ACP and UCP answer "how does the transaction happen?" PolicyCheck answers "is the seller safe for the agent to buy from?"

These aren't competing. They're complementary layers.

Current Status and Distribution

PolicyCheck is live at policycheck.tools with all endpoints in production. Discovery options:

x402 Bazaar -- listed #1 in the agent discovery registry
npm -- npm install -g policycheck-mcp for MCP integration
WebMCP -- pending PR #15 with GoogleChromeLabs/webmcp-tools
Coinbase AgentKit -- pending PR #948

The service is free to call for testing. x402 micropayments are available for production autonomous agent use.

Try It Now

curl -X POST https://policycheck.tools/api/v1/signed-assessment \
  -H "Content-Type: application/json" \
  -d '{"seller_url": "https://amazon.com"}'

Full API documentation: policycheck.tools/docs
Agent card: policycheck.tools/.well-known/agent.json

PolicyCheck is an independent third-party service. Sellers do not control or influence their own assessments.

DEV Community: Andy Smith