Agent Friendly
DEEP AGENTIC RUBRIC

Make your site agent friendly.

22 areas. 88 checks.

0/88checks reviewed
Your checklist

Mark reviewed checks. Copy your checklist.

Saved in this browser

Review progress is personal. Website rankings use a separate public-page benchmark.

Browse 22 rubric areas

Product feed

0 / 4

Products, prices, and stock an agent can read.

Parseable productsPublic
CAT-01 ↗

What good looks like

A structured feed or API returns stable product and variant IDs, explicit availability enums, and machine-readable attributes.

How to verify

Validate the declared JSON/XML schema on a recorded sample; report valid records / sampled records.

Unambiguous pricesPublic
CAT-02 ↗

What good looks like

Every sampled price has an explicit ISO currency, denomination and precision. Payment APIs using minor units use integers; documented decimal product prices are also unambiguous.

How to verify

Count compliant price fields; fail verified records with ambiguous units or missing currency.

Cache & freshness contractPublic
CAT-03 ↗

What good looks like

The response exposes an ETag or equivalent revision marker and documentation states a freshness interval.

How to verify

Record response headers, revision, and declared interval. Documentation alone does not establish freshness.

Feed matches checkoutTest
CAT-04 ↗

What good looks like

For identical variants and quantities, feed price/stock and sandbox checkout agree within the declared reconciliation window.

How to verify

Compare timestamped feed and checkout snapshots; record mismatches / compared variants and maximum observed lag.

See a code example ↗
catalog.response.json
{
  "revision": "catalog-42",
  "updated_at": "2026-10-10T18:00:00Z",
  "products": [{
    "id": "lamp_01",
    "variant_id": "warm_white",
    "availability": "in_stock",
    "price": { "amount": 12900, "currency": "USD" },
    "attributes": { "color_temperature_kelvin": 2700 }
  }]
}

Illustrative merchant contract. This is not an ACP feed schema. The refresh interval belongs in the published API contract.

Headless checkout

0 / 4

Create, pay, and complete without a screen.

Complete API flowTest
CHK-01 ↗

What good looks like

A documented headless flow can create/update a checkout, attach a delegated payment credential, and complete an authorized sandbox order.

How to verify

Execute one authorized fixture per supported flow; report completed flows / attempted flows.

Explicit state & totalsTest
CHK-02 ↗

What good looks like

Every tested mutation returns checkout/order identifiers, current state, currency, and authoritative item, tax, shipping, and total amounts.

How to verify

Validate responses against the merchant schema; record missing or inconsistent fields.

Invalid transitions fail clearlyTest
CHK-03 ↗

What good looks like

An unpaid or otherwise invalid completion returns the documented conflict error, typically 409, without an order or charge.

How to verify

Test the invalid fixture in a sandbox; inspect both HTTP response and resulting order/payment state.

Discoverable contractPublic
CHK-04 ↗

What good looks like

The API has a versioned OpenAPI specification or equivalent typed contract, including errors and supported transitions.

How to verify

Fetch and validate the contract; report resolvable operations and schema errors. A spec does not prove the flow runs.

See a code example ↗
checkout.response.http
HTTP/1.1 409 Conflict
Content-Type: application/json

{
  "error": {
    "code": "payment_required",
    "message": "Attach an authorized payment credential first."
  },
  "checkout_id": "chk_demo_01",
  "state": "awaiting_payment",
  "total": { "amount": 12900, "currency": "USD" }
}

Example error contract, not a live API response. An HTTP status alone cannot prove that no side effect occurred.

Scoped payment

0 / 4

Only act within the buyer’s permission.

No raw payment secretsTest
AUTH-01 ↗

What good looks like

The agent-facing payment flow accepts a delegated token or mandate, with no requirement for raw card numbers or account secrets.

How to verify

Inspect the contract and authorized test trace with redacted credential values.

Scope is enforcedTest
AUTH-02 ↗

What good looks like

The authorization binds allowed merchant/action, maximum amount, currency, and expiry or equivalent restrictions.

How to verify

Test in-scope and out-of-scope fixtures; count unauthorized actions accepted.

Fail closedTest
AUTH-03 ↗

What good looks like

Expired, invalid, revoked, or unverifiable authorization is rejected before any charge or order side effect.

How to verify

Replay each negative fixture and inspect the authoritative order/payment state.

Credentials stay redactedAudit
AUTH-04 ↗

What good looks like

Observed agent and merchant trace artifacts contain references or redacted tokens, without raw payment secrets.

How to verify

Review a scoped, redacted test trace. Full production log coverage remains unknown without an authorized audit.

See a code example ↗
authorization.fixture.json
{
  "credential_ref": "test_token_reference",
  "scope": {
    "merchant": "merchant.example",
    "action": "complete_checkout",
    "max_amount": 15000,
    "currency": "USD",
    "expires_at": "2026-10-10T18:30:00Z"
  },
  "expected_out_of_scope_result": "rejected_without_side_effect"
}

Test fixture description, not a valid signed credential. Validation and payment processing belong to the merchant’s supported protocol and provider.

Safe retries

0 / 4

One purchase, even after several retries.

Mutation coverageTest
IDEM-01 ↗

What good looks like

Every non-idempotent mutation documents and enforces an idempotency mechanism.

How to verify

Inventory the mutation operations, then test each documented mechanism in a sandbox.

Replay has one effectTest
IDEM-02 ↗

What good looks like

Repeating the same operation and payload with the same key produces one logical effect and a consistent replay result.

How to verify

Send the identical sandbox fixture twice; compare order/charge counts and response identifiers.

Key collisions are rejectedTest
IDEM-03 ↗

What good looks like

Reusing a key with a materially different payload returns a documented error without executing the new operation.

How to verify

Change quantity or amount in a sandbox replay; inspect the resulting state.

Concurrency & lifetimeTest
IDEM-04 ↗

What good looks like

Concurrent duplicate requests remain safe within the documented key scope and retention window.

How to verify

Run a bounded duplicate fixture set; report effect count and the key’s declared lifetime.

See a code example ↗
sandbox-request.http
POST /sandbox/checkouts/chk_demo_01/complete HTTP/1.1
Host: merchant.example
Authorization: Bearer TEST_SCOPED_TOKEN
Idempotency-Key: demo-operation-01
Content-Type: application/json

{ "payment_credential_ref": "test_token_reference" }

# Repeat this exact fixture with the same key.
# Expected: one order, one payment effect, stable order reference.

Authorized sandbox only. Replay semantics differ by API and version; verify the merchant’s contract rather than assuming every provider behaves identically.

Webhooks

0 / 4

Reliable updates when an order changes.

Signature validationTest
EVT-01 ↗

What good looks like

The contract documents a signature scheme; valid fixtures are accepted and tampered fixtures are rejected.

How to verify

Verify known-good and modified event fixtures using the documented verifier.

Stable event identityTest
EVT-02 ↗

What good looks like

Events have stable IDs and a documented delivery guarantee; repeated deliveries are deduplicated without losing updates.

How to verify

Deliver the same sandbox event twice and measure processed effects.

Recoverable deliveryTest
EVT-03 ↗

What good looks like

The contract documents retry/backoff and supports authorized replay, event retrieval, or equivalent gap recovery.

How to verify

Miss a sandbox event, recover it using the supported mechanism, and verify the resulting state.

State-to-event consistencyAudit
EVT-04 ↗

What good looks like

Order state changes and emitted events reconcile without unexplained missing transitions.

How to verify

Compare a scoped state/event audit. An outbox assertion alone is not behavioral verification.

See a code example ↗
order-event.fixture.json
{
  "event_id": "evt_demo_01",
  "type": "order.confirmed",
  "occurred_at": "2026-10-10T18:05:00Z",
  "order_id": "ord_demo_01",
  "checkout_id": "chk_demo_01",
  "state": "confirmed"
}

Illustrative event payload. Signature metadata belongs in the documented transport contract. Do not treat delivery as ordered or exactly-once unless that guarantee is demonstrated.

Agent operations

0 / 4

Trace requests and protect your capacity.

Agent attributionAudit
OPS-01 ↗

What good looks like

Recorded test requests and orders resolve to an authenticated agent/client identity, not only a spoofable User-Agent string.

How to verify

Follow a test request ID from client to order record; report linked requests / sampled requests.

Per-agent quotasTest
OPS-02 ↗

What good looks like

Quotas are defined per authenticated agent or equivalent principal, and one agent’s fixture does not consume another’s allocation.

How to verify

Use a small, explicitly authorized sandbox quota and compare two isolated principals.

Usable rate-limit responseTest
OPS-03 ↗

What good looks like

A throttled sandbox request returns 429 plus a parseable Retry-After value or the explicitly documented equivalent backoff contract.

How to verify

Inspect a sandbox response; do not intentionally exhaust a live merchant quota.

Auditable authorization chainAudit
OPS-04 ↗

What good looks like

A sampled order links to the authorizing token/mandate reference, checkout, agent identity, and payment result without exposing secret material.

How to verify

Inspect a scoped redacted audit artifact and reconcile its identifiers.

See a code example ↗
quota.response.http
HTTP/1.1 429 Too Many Requests
Content-Type: application/json
Retry-After: 30

{
  "error": { "code": "agent_quota_exceeded" },
  "request_id": "req_demo_01",
  "retry_after_seconds": 30
}

Illustrative response. Respect the declared retry interval; quota tests belong in a sandbox with agreed limits.

Discovery & access

0 / 4

Can an agent find the right public pages and understand access rules?

Canonical discoveryPublic
DISC-01 ↗

What good looks like

Each sampled public page has a stable canonical URL and important pages are linked from navigation or a sitemap.

How to verify

Sample at least five distinct pages; count resolvable canonical URLs and discoverable destinations.

Agent policy clarityPublic
DISC-02 ↗

What good looks like

Published access policy distinguishes training, search, interactive shopping and authorized integrations without treating robots silence as permission.

How to verify

Record named agents, allowed scope and policy sources; compare policy text and applicable robots directives for each sampled route.

Discoverable machine contractPublic
DISC-03 ↗

What good looks like

Supported feeds, APIs or connectors are linked from accessible developer documentation with versions and authentication requirements.

How to verify

Fetch every advertised contract; report reachable contracts / advertised contracts and unresolved references.

Honest blocked statesTest
DISC-04 ↗

What good looks like

Denied or unavailable routes return explicit status and a documented authorized alternative when one exists; agents are not asked to bypass controls.

How to verify

Observe a permitted denial fixture; record HTTP status, reason and alternative route. Do not evade a challenge.

See a code example ↗
discovery.assessment.json
{
  "id": "DISC-01",
  "result": "unknown",
  "evidence_level": "none",
  "environment": "public",
  "metrics": {},
  "next_step": "Sample at least five distinct pages; count resolvable canonical URLs and discoverable destinations."
}

Illustrative partial assessment record, not a complete schema-valid report or proof of passing. Attach actual measured evidence; use the full assessment schema for submission.

Readable pages & structure

0 / 4

Can people and agents extract the same meaning from a page?

Meaningful initial contentPublic
HTML-01 ↗

What good looks like

Public pages expose meaningful readable content in initial HTML or a documented accessible equivalent.

How to verify

Compare initial HTML, rendered DOM and public facts on five pages; report matching factual fields / expected fields.

Headings and landmarksPublic
HTML-02 ↗

What good looks like

Sampled pages have descriptive titles, ordered headings and named main/navigation regions.

How to verify

Count pages with usable titles and landmarks; record missing or misleading headings in DOM artifacts.

Names, roles and statesPublic
HTML-03 ↗

What good looks like

Interactive controls expose accurate accessible names, roles and current states consistent with visible labels.

How to verify

Inspect at least ten controls across pages; count correctly named controls / sampled controls and state mismatches.

Equivalent nonvisual informationPublic
HTML-04 ↗

What good looks like

Images, tables and multimedia expose the information needed to decide in text or accessible alternatives.

How to verify

Compare critical facts in images/tables/media against text alternatives; list missing facts and affected tasks.

See a code example ↗
semantics.assessment.json
{
  "id": "HTML-01",
  "result": "unknown",
  "evidence_level": "none",
  "environment": "public",
  "metrics": {},
  "next_step": "Compare initial HTML, rendered DOM and public facts on five pages; report matching factual fields / expected fields."
}

Illustrative partial assessment record, not a complete schema-valid report or proof of passing. Attach actual measured evidence; use the full assessment schema for submission.

Browser actions & human clarity

0 / 4

Can a browser agent complete ordinary tasks through clear controls?

Keyboard-operable task pathsTest
BROW-01 ↗

What good looks like

Key tasks can be navigated with keyboard input and visible focus without traps.

How to verify

Execute three applicable task paths with keyboard input; report completed paths / attempted paths and focus failures.

Stable action targetsTest
BROW-02 ↗

What good looks like

Controls remain identifiable across layout changes and do not require brittle screen coordinates.

How to verify

Repeat task selection at desktop/mobile widths; record semantic locator success rate and ambiguous matches.

Observable loading and completionTest
BROW-03 ↗

What good looks like

Loading, empty, error and success states are distinguishable in the DOM and do not hide failed actions.

How to verify

Exercise each state fixture; count correctly exposed states / attempted states and capture DOM evidence.

Responsive clarityPublic
BROW-04 ↗

What good looks like

Content and essential controls remain usable at narrow widths and zoom without clipped critical facts.

How to verify

Measure clipping and task completion at declared device widths and zoom levels; record viewport dimensions.

See a code example ↗
browser.assessment.json
{
  "id": "BROW-01",
  "result": "unknown",
  "evidence_level": "none",
  "environment": "sandbox",
  "metrics": {},
  "next_step": "Execute three applicable task paths with keyboard input; report completed paths / attempted paths and focus failures."
}

Illustrative partial assessment record, not a complete schema-valid report or proof of passing. Attach actual measured evidence; use the full assessment schema for submission.

Product suitability & evidence

0 / 4

Can an agent match a product to a real person’s constraints?

Decision-relevant specificationsPublic
FACT-01 ↗

What good looks like

Sampled variants expose dimensions, materials, weight, compatibility and other applicable facts with explicit units.

How to verify

Define the category-specific required fields before sampling; count populated applicable fields / required fields across at least ten variants.

Use cases and limitationsPublic
FACT-02 ↗

What good looks like

Descriptions state suitable use cases and limitations, and do not invent performance claims or repeat keywords as evidence.

How to verify

For five realistic buyer prompts, map every decisive constraint to a sourced fact or explicit unknown; report supported constraints / total constraints.

Traceable claimsPublic
FACT-03 ↗

What good looks like

Certifications, ingredients, safety or performance claims link to current evidence for the exact variant and claim scope.

How to verify

Sample claimed attributes; count traceable claim-to-variant evidence links and expired or unsupported claims.

Visible and structured facts agreePublic
FACT-04 ↗

What good looks like

Structured product data agrees with the visible variant details, price, currency and availability.

How to verify

Compare paired visible/feed snapshots for ten variants; report mismatched fields / compared fields and timestamps.

See a code example ↗
product-facts.assessment.json
{
  "id": "FACT-01",
  "result": "unknown",
  "evidence_level": "none",
  "environment": "public",
  "metrics": {},
  "next_step": "Define the category-specific required fields before sampling; count populated applicable fields / required fields across at least ten variants."
}

Illustrative partial assessment record, not a complete schema-valid report or proof of passing. Attach actual measured evidence; use the full assessment schema for submission.

Forms, validation & recovery

0 / 4

Can an agent provide valid input and recover from mistakes?

Explicit input contractsPublic
FORM-01 ↗

What good looks like

Fields have labels, expected formats, required state and associated instructions.

How to verify

Inspect ten fields; count fields with complete labels/constraints and compare client/API validation.

Actionable validation errorsTest
FORM-02 ↗

What good looks like

Invalid values produce field-associated errors with stable machine codes where APIs are offered.

How to verify

Submit bounded invalid fixtures in a sandbox; report actionable errors / invalid inputs and preserved valid fields.

No surprise mutationsTest
FORM-03 ↗

What good looks like

Selection and navigation do not trigger purchases, subscriptions or destructive changes without an explicit final action.

How to verify

Record side-effect counts during navigation/input fixtures; require zero unexpected mutations.

Recoverable interruptionsTest
FORM-04 ↗

What good looks like

Session expiry, timeouts and failed submissions preserve safe input or explain how to resume without duplicates.

How to verify

Interrupt two fixture workflows; measure recoverable state and duplicate mutation counts.

See a code example ↗
forms.assessment.json
{
  "id": "FORM-01",
  "result": "unknown",
  "evidence_level": "none",
  "environment": "public",
  "metrics": {},
  "next_step": "Inspect ten fields; count fields with complete labels/constraints and compare client/API validation."
}

Illustrative partial assessment record, not a complete schema-valid report or proof of passing. Attach actual measured evidence; use the full assessment schema for submission.

Cart, quotes & purchase clarity

0 / 4

Does the buyer know exactly what will happen before approving?

Variant and quantity identityTest
CART-01 ↗

What good looks like

Cart lines identify exact variants, quantities, unit prices and item availability.

How to verify

Create five fixture carts; compare requested and returned variant/quantity/price fields with zero unexplained substitutions.

Complete preapproval totalTest
CART-02 ↗

What good looks like

Shipping, tax, fees, discounts and recurring commitments are disclosed before authorization with explicit currency.

How to verify

Compare displayed and authoritative totals for fixture destinations; report unexplained amount differences.

Quote validity and changesTest
CART-03 ↗

What good looks like

Quotes state expiry or revision, and material changes require renewed buyer approval rather than silent replacement.

How to verify

Change price/stock after a fixture quote; verify expiry/change detection and zero unauthorized completions.

Reviewable final actionTest
CART-04 ↗

What good looks like

The human or delegated authority can inspect the final order and enforce approval limits before execution.

How to verify

Record approval input, order revision and final effect; test one refused approval with zero order/payment effects.

See a code example ↗
cart.assessment.json
{
  "id": "CART-01",
  "result": "unknown",
  "evidence_level": "none",
  "environment": "sandbox",
  "metrics": {},
  "next_step": "Create five fixture carts; compare requested and returned variant/quantity/price fields with zero unexplained substitutions."
}

Illustrative partial assessment record, not a complete schema-valid report or proof of passing. Attach actual measured evidence; use the full assessment schema for submission.

Delivery, returns & aftercare

0 / 4

Can an agent verify promises and resolve what happens after buying?

Destination-specific deliveryTest
SHIP-01 ↗

What good looks like

Delivery estimates identify destination scope, order cutoff, business-day rules and unavailable regions.

How to verify

Test five allowed destination fixtures; record estimate completeness and discrepancies against shipping rules.

Return and warranty factsPublic
SHIP-02 ↗

What good looks like

Return windows, exclusions, costs and warranty scope are public and linked to relevant products.

How to verify

Sample five products; count applicable return/warranty answers with explicit sources and exclusions.

Order status and supportTest
SHIP-03 ↗

What good looks like

Authorized clients can retrieve state, shipment references and a documented support/escalation route.

How to verify

Follow three sandbox order states; report retrievable transitions / expected transitions and support-route availability.

Cancellation and refundsTest
SHIP-04 ↗

What good looks like

Supported cancel/refund actions state eligibility, money amounts, timing and final state with safe retries.

How to verify

Exercise eligible and ineligible sandbox cases and one retry; report duplicate refund effects and unexplained outcomes.

See a code example ↗
fulfillment.assessment.json
{
  "id": "SHIP-01",
  "result": "unknown",
  "evidence_level": "none",
  "environment": "sandbox",
  "metrics": {},
  "next_step": "Test five allowed destination fixtures; record estimate completeness and discrepancies against shipping rules."
}

Illustrative partial assessment record, not a complete schema-valid report or proof of passing. Attach actual measured evidence; use the full assessment schema for submission.

Accounts & session boundaries

0 / 4

Does sign-in preserve intent while protecting private data?

Intent survives sign-inTest
ACCT-01 ↗

What good looks like

Authentication returns the user to the requested safe action or page without losing pending non-sensitive input.

How to verify

Test sign-in, confirmation and recovery callbacks on approved origins; report preserved intents / fixture journeys.

Session expiry is explicitTest
ACCT-02 ↗

What good looks like

Expired sessions stop private actions and offer reauthentication without exposing private results.

How to verify

Expire one fixture token; measure private reads/writes rejected and successful recovery after sign-in.

Cross-account isolationTest
ACCT-03 ↗

What good looks like

Private records and actions are authorized by server/database policy for the current principal.

How to verify

Use two disposable principals; require zero unauthorized reads or mutations across each private resource type.

Ownership is provenTest
ACCT-04 ↗

What good looks like

Claims to manage a domain or organization require verifiable ownership rather than a URL or client-supplied flag.

How to verify

Test valid, invalid and replayed ownership proofs; record unauthorized claims accepted and proof expiry rules.

See a code example ↗
accounts.assessment.json
{
  "id": "ACCT-01",
  "result": "unknown",
  "evidence_level": "none",
  "environment": "sandbox",
  "metrics": {},
  "next_step": "Test sign-in, confirmation and recovery callbacks on approved origins; report preserved intents / fixture journeys."
}

Illustrative partial assessment record, not a complete schema-valid report or proof of passing. Attach actual measured evidence; use the full assessment schema for submission.

Privacy, consent & minimization

0 / 4

Does useful feedback avoid exposing the person behind it?

Minimal buyer disclosureAudit
PRIV-01 ↗

What good looks like

Agent requests and feedback disclose only necessary permitted constraints, avoiding raw personal histories and credentials.

How to verify

Review a consented redacted sample; count unnecessary sensitive fields / sampled fields and document purpose.

Consent and revocationTest
PRIV-02 ↗

What good looks like

Sharing and delegated actions follow explicit consent scope with revocation and expiry enforcement.

How to verify

Test consent grant, withdrawal and expired fixture permissions; require zero out-of-scope disclosures.

Retention and deletionAudit
PRIV-03 ↗

What good looks like

Stored feedback and agent traces have documented retention and authorized deletion/export behavior.

How to verify

Inspect retention configuration and exercise a disposable export/delete fixture; record retained identifiers and completion time.

Safe public aggregationAudit
PRIV-04 ↗

What good looks like

Public metrics distinguish simulations, submissions and independent users and avoid small-cohort identifying detail.

How to verify

Reconcile public aggregates to a scoped redacted fixture dataset; count provenance errors and disclosed identifying fields.

See a code example ↗
privacy.assessment.json
{
  "id": "PRIV-01",
  "result": "unknown",
  "evidence_level": "none",
  "environment": "sandbox",
  "metrics": {},
  "next_step": "Review a consented redacted sample; count unnecessary sensitive fields / sampled fields and document purpose."
}

Illustrative partial assessment record, not a complete schema-valid report or proof of passing. Attach actual measured evidence; use the full assessment schema for submission.

Security & adversarial inputs

0 / 4

Can the site treat agent inputs as untrusted data?

Untrusted text stays dataTest
SEC-01 ↗

What good looks like

Retrieved pages and submitted feedback cannot redefine agent/system authority or trigger actions without authorization.

How to verify

Run isolated prompt-injection fixtures; count unauthorized tool calls or disclosures, and preserve the attack/result artifacts.

Server-side input boundariesTest
SEC-02 ↗

What good looks like

URLs, identifiers, amounts and callbacks are validated server-side; private/internal network targets are denied.

How to verify

Run bounded invalid-input and SSRF fixtures against an authorized isolated service; count accepted prohibited targets.

Credential and transport hygieneAudit
SEC-03 ↗

What good looks like

Secrets remain server-side, scoped and redacted; HTTPS and supported authentication protect private actions.

How to verify

Inspect a scoped configuration and redacted traces; count exposed secrets and unauthenticated private operations.

Abuse controls without blanket claimsTest
SEC-04 ↗

What good looks like

Feedback/tool endpoints apply bounded quotas and provenance controls without presenting spoofed bot identity as verified users.

How to verify

Test duplicate/replay/spoofed identity fixtures within agreed limits; count incorrect identity attributions and duplicate effects.

See a code example ↗
security.assessment.json
{
  "id": "SEC-01",
  "result": "unknown",
  "evidence_level": "none",
  "environment": "sandbox",
  "metrics": {},
  "next_step": "Run isolated prompt-injection fixtures; count unauthorized tool calls or disclosures, and preserve the attack/result artifacts."
}

Illustrative partial assessment record, not a complete schema-valid report or proof of passing. Attach actual measured evidence; use the full assessment schema for submission.

APIs, MCP & tool contracts

0 / 4

Can a supported agent discover and invoke a compact typed interface?

Typed tool interfacesPublic
TOOL-01 ↗

What good looks like

Supported tools have accurate names, descriptions, schemas, errors and documented input/output limits.

How to verify

Validate advertised schemas and ten representative fixtures; report valid contracts / advertised contracts.

Read and write boundariesTest
TOOL-02 ↗

What good looks like

Tools clearly distinguish read-only, reversible and consequential actions; real authorization governs execution.

How to verify

Inventory tools and execute allowed/denied sandbox fixtures; count mislabeled effects and permission violations.

Connector identity and authorizationTest
TOOL-03 ↗

What good looks like

MCP/API clients use the supported authorization flow with appropriate audience/scope checks rather than passing unrelated tokens through.

How to verify

Inspect the current protocol contract and test isolated wrong-audience/scope fixtures; require zero unauthorized accepted requests.

Bounded response costTest
TOOL-04 ↗

What good looks like

Responses expose only necessary facts, support pagination/field selection where needed and publish tested payload limits.

How to verify

Measure response bytes, retrieval requests and task success on ten fixtures against declared budgets; do not use small payload size alone as readiness.

See a code example ↗
connectors.assessment.json
{
  "id": "TOOL-01",
  "result": "unknown",
  "evidence_level": "none",
  "environment": "public",
  "metrics": {},
  "next_step": "Validate advertised schemas and ten representative fixtures; report valid contracts / advertised contracts."
}

Illustrative partial assessment record, not a complete schema-valid report or proof of passing. Attach actual measured evidence; use the full assessment schema for submission.

Reliability & failure recovery

0 / 4

Can the system stay understandable when dependencies fail?

Timeout and retry contractsTest
REL-01 ↗

What good looks like

Clients receive bounded timeouts, retryable/nonretryable error classes and backoff guidance.

How to verify

Inject permitted latency and failure fixtures; record p50/p95 response times, retry counts and final outcomes.

Durable background workTest
REL-02 ↗

What good looks like

Long-running jobs survive worker restarts and expose stable job IDs, state and terminal failures.

How to verify

Restart an isolated worker mid-job; compare job/effect counts and observable status before/after restart.

Reconciliation after uncertaintyTest
REL-03 ↗

What good looks like

Ambiguous client timeouts can be resolved through authoritative status without reissuing a new logical purchase.

How to verify

Drop one sandbox completion response; query authoritative state and require one logical effect after recovery.

Contract compatibilityPublic
REL-04 ↗

What good looks like

Breaking changes are versioned and migration/deprecation dates are documented for feeds and actions.

How to verify

Compare two retained contract versions and client fixtures; report breaking fields/operations and documented migration coverage.

See a code example ↗
reliability.assessment.json
{
  "id": "REL-01",
  "result": "unknown",
  "evidence_level": "none",
  "environment": "sandbox",
  "metrics": {},
  "next_step": "Inject permitted latency and failure fixtures; record p50/p95 response times, retry counts and final outcomes."
}

Illustrative partial assessment record, not a complete schema-valid report or proof of passing. Attach actual measured evidence; use the full assessment schema for submission.

Locale, time & money

0 / 4

Do facts keep the same meaning across regions?

Explicit units and datesPublic
LOC-01 ↗

What good looks like

Dates/times state timezone and relevant calendar rules; dimensions and quantities state units.

How to verify

Sample twenty applicable values; count unambiguous unit/timezone values / sampled values.

Regional prices and eligibilityTest
LOC-02 ↗

What good looks like

Currency, geography, taxes, inventory and eligibility are tied to the buyer-selected region.

How to verify

Compare five region fixtures; record mismatched currency/availability and unannounced regional fallbacks.

Language parityPublic
LOC-03 ↗

What good looks like

Supported languages preserve decisive product/policy facts and recognizable action semantics.

How to verify

Compare the same five pages in two supported locales; report decisive fact mismatches / compared facts.

Accessible localizationPublic
LOC-04 ↗

What good looks like

Language metadata, right-to-left layouts where supported and translated control names remain usable.

How to verify

Inspect supported locale DOMs and keyboard flows; count correctly declared languages and missing translated control names.

See a code example ↗
localization.assessment.json
{
  "id": "LOC-01",
  "result": "unknown",
  "evidence_level": "none",
  "environment": "public",
  "metrics": {},
  "next_step": "Sample twenty applicable values; count unambiguous unit/timezone values / sampled values."
}

Illustrative partial assessment record, not a complete schema-valid report or proof of passing. Attach actual measured evidence; use the full assessment schema for submission.

Feedback & improvement loop

0 / 4

Can people and agents turn a blocker into a verified improvement?

Simple feedback entryTest
FDBK-01 ↗

What good looks like

Public pages provide a usable human feedback route and a documented structured agent endpoint when supported.

How to verify

Submit one disposable human and agent fixture; verify receipt identifiers and correct owner routing.

Evidence and provenanceAudit
FDBK-02 ↗

What good looks like

Feedback records page/context, blocker, source kind and evidence without inventing a customer or purchase outcome.

How to verify

Validate ten redacted fixtures against the feedback schema; count incomplete provenance and unsupported outcome claims.

Useful verified responsesTest
FDBK-03 ↗

What good looks like

Owners can publish sourced answers and agents can retrieve revisions with timestamps without seeing private feedback.

How to verify

Create an authorized answer fixture, retrieve it publicly and test unauthorized edits; report stale revisions and leakage.

Comparable follow-upTest
FDBK-04 ↗

What good looks like

After a fix, the same task/profile/version is remeasured and unresolved cases remain visible.

How to verify

Replay a recorded baseline suite; report paired task outcomes, score/version changes and remaining failures.

See a code example ↗
feedback.assessment.json
{
  "id": "FDBK-01",
  "result": "unknown",
  "evidence_level": "none",
  "environment": "sandbox",
  "metrics": {},
  "next_step": "Submit one disposable human and agent fixture; verify receipt identifiers and correct owner routing."
}

Illustrative partial assessment record, not a complete schema-valid report or proof of passing. Attach actual measured evidence; use the full assessment schema for submission.

Harness, evidence & regression

0 / 4

Can another builder reproduce the assessment?

Representative task setPublic
EVAL-01 ↗

What good looks like

The assessment declares persona constraints, task scope, pages/variants and sample selection before testing.

How to verify

Record at least five pages and ten applicable task fixtures, with denominators and exclusions; separate public and sandbox evidence.

Reproducible artifactsAudit
EVAL-02 ↗

What good looks like

Each result links timestamped inputs, expected/observed outcomes, environment, versions and redacted artifacts.

How to verify

Validate all reported checks; count results with complete replay metadata / reported results.

Measured task outcomesTest
EVAL-03 ↗

What good looks like

Success rate, retries, latency and cost use defined units and do not treat documentation coverage as executed success.

How to verify

Replay the fixed suite; report successes / attempts, p50/p95 latency and request/token cost with environment and sample size.

Regression and comparison controlsTest
EVAL-04 ↗

What good looks like

Before/after comparisons retain task/data/protocol versions and report failed retrievals and unknowns rather than hiding them.

How to verify

Repeat unchanged and changed fixture runs; count invalid comparisons and verify all terminal outcomes are retained.

See a code example ↗
evaluation.assessment.json
{
  "id": "EVAL-01",
  "result": "unknown",
  "evidence_level": "none",
  "environment": "public",
  "metrics": {},
  "next_step": "Record at least five pages and ten applicable task fixtures, with denominators and exclusions; separate public and sandbox evidence."
}

Illustrative partial assessment record, not a complete schema-valid report or proof of passing. Attach actual measured evidence; use the full assessment schema for submission.

Evidence matters.

A claim isn’t a test. Keep these three levels separate.

✓Verified

Behavior observed in a reproducible test.

≡Documented

Described in docs; not demonstrated.

○Claimed

An assertion without supporting evidence.

Results & assessment rules

Pass and fail require verified evidence. Missing evidence stays unknown. Not applicable requires a scope reason. Review marks above are not evidence of a pass.

Deep transaction checks are not yet automated. Current rankings use af-html-1.2 and at least five readable HTML pages. No deep score is inferred from those rankings.

Read-only checks are public. Mutations, quota tests, and private audits require explicit authorization and appropriate sandbox fixtures.

FOR BUILDING AGENTS

Read it. Test it. Show the evidence.

Stable check IDs and structured results for your harness.

Assessment example & reading commands
assessment.example.json
{
  "rubric_version": "dar-0.2",
  "merchant": "merchant.example",
  "assessed_at": "2026-10-10T18:05:00Z",
  "deep_score": null,
  "checks": [
    {
      "id": "IDEM-02",
      "result": "pass",
      "evidence_level": "verified",
      "observed_at": "2026-10-10T18:05:00Z",
      "environment": "sandbox",
      "method": "Two identical authorized requests with the same key",
      "source_url": "https://merchant.example/docs/idempotency",
      "artifacts": [
        "redacted-request-pair.json",
        "order-effect-count.json"
      ],
      "metrics": {
        "requests": 2,
        "orders_created": 1,
        "payment_effects": 1
      }
    },
    {
      "id": "EVT-04",
      "result": "unknown",
      "evidence_level": "claimed",
      "observed_at": "2026-10-10T18:05:00Z",
      "environment": "documentation",
      "method": "Merchant statement; no audit artifact",
      "source_url": "https://merchant.example/docs/events",
      "artifacts": [],
      "metrics": {}
    }
  ]
}

Fictional fixture. Deep score stays null until a separate verified scoring system exists.

read-the-rubric.sh
# Read-only. Replace the origin for your deployed instance.
curl -fsS http://localhost:3100/rubric.md
curl -fsS http://localhost:3100/rubric.json
curl -fsS http://localhost:3100/rubric.schema.json
Protocols & sources

ACP, AP2, or an equivalent typed contract can supply evidence. A protocol badge or MCP tool listing alone does not demonstrate transaction reliability. Record the protocol and version.

This is Agent Friendly’s proposed assessment specification, inspired by practitioner guidance; not a certification or industry standard.