EVIDIQ on OKX.AI: What an OKX.AI Agent Service Provider Actually Does

Picture this: an OKX agent gets pinged with a job offer from a counterparty agent. Same marketplace, same listing format, wallet looks plausible. As of 2026, the honest question isn't "is the offer attractive" — it's "should I even engage?" Three months ago, the honest answer to that second question was "yolo and pray." Today, the agent calls EVIDIQ, gets back a deterministic trust score and a recommendation, and decides. That's what an OKX.AI agent service provider is actually for.

What an A2MCP Agent Service Provider Is on OKX.AI

EVIDIQ is an OKX.AI agent service provider that returns a deterministic 0–100 trust score plus a proceed/caution recommendation whenever another agent is about to act on a counterparty. It's listed in the OKX marketplace and called on-demand via the A2MCP surface, not subscribed to. You pay per call.

OKX runs two distinct shapes of agent commerce, and they're easy to confuse. The first is A2A — agent to agent — which is the negotiated, escrowed, contract-driven flow. Two parties agree on terms, an escrow contract holds the funds, work happens, settlement happens. Think of it as the "deal" lane. That's where most service-level transactions on OKX.AI actually settle.

The second shape is A2MCP — agent to Model Context Protocol. It's not a deal. It's a tool call. An agent invokes a registered tool, gets structured output back, and uses that output to inform its next action. No escrow, no bilateral contract — just a request and a signed response. EVIDIQ is registered in this surface. When your OKX agent needs to know "should I trust this counterparty right now," it makes a tool call to EVIDIQ rather than opening an A2A negotiation.

Here's the thing most people miss: being an OKX.AI agent service provider is not the same role as being a counterparty. EVIDIQ doesn't take the job your agent was offered. It doesn't hold your money. It doesn't counter-sign anything. It produces a trust score and a recommendation, then your agent — or your code — decides what to do with that signal.

That separation is the whole point. Trust belongs as a query, not a side effect of the deal.

Where EVIDIQ Sits in an OKX Agent's Decision Loop

Let's walk through a real flow. Your OKX agent is sitting in an event loop. A peer agent on the marketplace sends it a job offer — say, "I'll render this 3D asset for 0.4 USDT0 on X Layer, deliver in 12 minutes." Before your agent responds, before any A2A handshake, before any escrow opens, it has to decide: is this counterparty safe to engage with at all?

That's the exact decision point. Here's the sequence we've seen work in production:

1. Receive the offer event from the OKX.AI message bus.
2. Extract the counterparty's identifier (wallet address, agent id, or ENS).
3. Call EVIDIQ's verify_agent tool with that identifier, plus the declared capabilities relevant to the job.
4. Receive a structured response: identity, capability, reputation, risk sub-scores, a weighted final score, and a recommendation.
5. Branch on the recommendation: proceed, proceed_with_escrow, caution, or do_not_proceed.
6. Only then — if the verdict clears the threshold — open the A2A flow, accept the offer, and let escrow handle settlement.

[IMAGE_PROMPT: A flat technical illustration showing two abstract agent boxes connected by a dashed arrow, with a small verify_agent call routing through a third scoring box that outputs a 0–100 trust score dial and a recommendation chip. Modern dev aesthetic, blue and amber accents, abstract blockchain nodes and a faint 0G Storage anchor glyph in the background, no logos, no readable text.]

The four recommendations are deliberately distinct: proceed clears the counterparty for direct settlement; proceed_with_escrow clears it for engagement only if an A2A escrow contract is in place; caution means the signal is mixed or insufficient; do_not_proceed means identity or capability checks failed outright. Your agent can pick any policy on top — some treat caution as a hard stop, others treat it as require-escrow-and-a-small-job-first. EVIDIQ doesn't pick the policy; it gives you enough information to pick one yourself.

The step that used to be "hope" is now an auditable evidence bundle. Each verify_agent response is hashed (keccak256) and anchored on 0G Storage mainnet, with the anchor returning an on-chain transaction hash you can verify yourself. If you want to see exactly how the evidence is constructed and how the recommendation was derived, our EVIDIQ Notary docs walk through the full chain.

We built the probe deliberately bounded — a roughly 6 second GET against the counterparty's declared endpoint, checking reachability, TLS validity, and whether the endpoint serves a machine-readable skill, agent-card, or MCP surface. No crawling, no scraping, no impersonation risk. It's the minimum signal needed to score capability honestly, and it stays under the radar of the agent being probed.

One opinionated take: the trust decision should be a separate transaction from the deal. Conflating them is how you end up with "we escrow'd with a scammer because the escrow service said it was fine." Keep the score a query; keep the deal a deal.

Why Pay-Per-Call Instead of a Subscription Here

A subscription model assumes predictable volume. Trust verification isn't predictable.

A low-volume OKX agent might verify a counterparty twice a week. A high-frequency one — a market-making agent, an arbitrage router, a token-launch sniper — might verify fifty times a minute during peak windows. Same trust product, completely different cost profile. Charging both the same monthly rate is unfair in one direction and unprofitable in the other.

x402 solves this in a way subscription billing genuinely cannot. Each verify_agent call returns HTTP 402 with an accepts[] array (x402 v2 spec), naming the amount in USDT0, the network (X Layer), and the scheme (exact via EIP-3009 transferWithAuthorization). Your agent signs a one-time authorization, the call clears, and you move on. No account, no API key rotation, no monthly invoice, no proration dispute.

The economic fit is straightforward:

• Idle agents pay zero. No verification calls, no charges. A subscription charges you for the months your agent is parked.
• Hot agents pay only for what they use. Spike traffic during an airdrop hunt? You pay for the spike. Subscription tiers either cap you or upcharge you.
• No key management. The agent authorizes payment with the same wallet it uses for A2A settlement. One key surface, not two.
• Micropayment-native. A score call costs fractions of a cent in USDT0. You can verify ten counterparties before deciding whether to engage with one.

We chose x402 specifically because agents are the payer, not a human with a credit card. Humans tolerate subscriptions because billing friction is low and habits are sticky. Agents optimize ruthlessly against recurring cost. The math is simple: metered pricing wins when the buyer is software.

If you want to see the exact challenge format and how your agent should handle the 402, the EVIDIQ docs have copy-pasteable examples for the common runtimes.

Getting Listed Is Not the Same as Being Trusted

This is worth saying plainly: OKX listing EVIDIQ as an OKX.AI agent service provider is OKX's own marketplace and review process. It means EVIDIQ passed whatever checks OKX applies to providers — packaging, basic quality, integration shape. It does not mean EVIDIQ has endorsed every counterparty your agent meets on the marketplace. And it definitely doesn't mean the counterparty you're about to deal with has been vetted by EVIDIQ.

Two different trust axes, easy to conflate:

• Marketplace listing — is this provider allowed to sell tools in the OKX marketplace? Reviewed by OKX.
• Counterparty trust score — is this specific third-party agent safe to engage with right now? Scored by EVIDIQ's verify_agent on demand.

[IMAGE_PROMPT: A clean two-column comparison diagram. Left column labeled Marketplace Listing with a checked clipboard icon and a small Reviewed by OKX chip. Right column labeled Counterparty Trust Score with a semicircular gauge dial reading 0–100 and four small scoring boxes underneath. Connecting arrows run between an OKX marketplace box at the top and an agent decision box at the bottom. Muted teal and slate palette, abstract icons, no real logos, no readable text other than the two column labels.]

The reason this matters: if your agent assumes "EVIDIQ is in the marketplace, therefore every other agent there is safe," you'll burn money on bad counterparties. The marketplace is a directory. EVIDIQ's product is a per-call verification of whoever your agent is actually about to transact with. Two distinct services.

Worth noting: EVIDIQ's score is deterministic and explainable. Same inputs — same counterparty identifier, same declared capabilities, same probe result — produce the same score every time. The formula is identity*0.3 + capability*0.3 + reputation*0.2 + (100-risk)*0.2, each component on a 0–100 scale. There is no model in the loop picking winners. If you disagree with a score, you can re-fetch the inputs, recompute, and arrive at the same number — or prove us wrong in public.

For deeper mechanics, the EVIDIQ Sentinel docs cover how the probe runs and what evidence is captured per call, and the EVIDIQ Operator docs cover how to integrate the MCP tools into your own agent runtime. The high-level product page at EVIDIQ is also worth a look.