X-EGO Human Proof

An MCP server that lets AI agents verify there is a real, present human on the other end — using passkeys and short-lived, EdDSA-signed proofs. No accounts, no personal data, no cross-service tracking.

What it is.

X-EGO Human Proof exposes the X-EGO proof-of-human verification as tools for AI agents over the Model Context Protocol (MCP). It gives any MCP-capable agent three tools: request a verification link for a user, verify the signed proof the user brings back, and check whether a returning user has been seen before.

The human side of the flow is a Planetary ID — a digital identity bound to a person by their passkey (fingerprint or Face ID, WebAuthn). The human verifies on x-ego.com/verify; their biometrics never leave their device.

Endpoints

Three tools, one loop.

1 · xego_request_proof_url

Returns the URL the agent sends a human user to, so they can prove they are human. The user verifies on the page with their passkey and receives a short-lived signed token (JWT), which they hand back to the agent. This tool performs no verification itself — it only prepares the link. No personal data is transferred.

Returns: verification_url (link for the user), audience (the normalized hostname — pass this exact value as expected_audience to xego_verify_proof), and instructions. A non-normalizable audience returns invalid_audience.

2 · xego_verify_proof

Verifies the token (JWT) the user brought back. It cryptographically checks the Ed25519 signature against the X-EGO public keys, validates the claims, the expiry, and the audience. A valid result means: there is a verified human on the other end who holds the passkey.

Paid tool: $0.05 per call in USDC via the x402 protocol — or free with a pilot operator key. Invalid input is rejected before any payment. See 07 · Pricing.

Returns on success: valid: true, pairwise_id (anonymous ID, stable per user-and-audience), audience, expires_at (Unix time), human_verified: true, xego_verified (boolean — the proof is backed by a paid Planetary ID), and rarity (string or null — the rarity of the backing ID; low entropy, never the ID number). When mark_as_seen was requested, marked_seen (boolean) reports whether the permanent ledger write succeeded.

Onboarding signal: if the signature is valid but the token is not backed by a paid Planetary ID (xego_verified: false — legacy tokens), the result additionally carries status: "planetary_id_required" and a planetary_id_onboarding object with explanation, registration_url, and next_step: send the user back to the same verification URL — the page sells the Planetary ID inline (one-time €3) and continues the verification automatically after purchase, so the agent just repeats the flow with the fresh token. A user without any passkey hits the same inline purchase directly on the verification page, with the audience preserved end-to-end.

Returns on failure: valid: false with a machine-readable code and a human-readable reason (see error codes below).

3 · xego_check_pairwise_seen_before

Checks whether a given pairwise ID has already been seen within an audience. It protects against one person acting as multiple different users — multiple accounts, repeat voting, and similar. Only the pair (audience, pairwise_id) and the time of first occurrence are recorded. No personal data.

Paid tool: $0.01 per call in USDC via the x402 protocol — or free with a pilot operator key. Invalid input is rejected before any payment. See 07 · Pricing.

Returns: seen_before (boolean), first_seen (Unix time or null), recorded_now (boolean). The ledger is persistent — records survive across sessions. Protection is per audience — pairwise IDs never link across services, so this is per-service protection, not a global registry of humans.

From request to proof.

1. Agent calls xego_request_proof_url with its service domain as audience and receives a verification URL.
2. Agent sends the URL to the human user.
3. User opens x-ego.com/verify?audience=…, sees exactly which service the proof is being issued for, and approves with their passkey (fingerprint / Face ID). The biometric check happens entirely on their device — WebAuthn with user verification required. A user without a Planetary ID buys one right on the page (one-time €3, Stripe Checkout), sets up their passkey, and the verification continues automatically — the audience is preserved through the whole purchase.
4. X-EGO validates the passkey assertion and signs a short-lived JWT.
5. User copies the token and hands it to the agent. The page shows a live countdown of the token's validity.
6. Agent calls xego_verify_proof with the token and its expected_audience. Optionally it calls xego_check_pairwise_seen_before to detect returning users.

Anatomy of a proof.

Proofs are JWTs signed with EdDSA (Ed25519). The verifier accepts exclusively alg: EdDSA — a defense against algorithm-confusion and none attacks. Claims:

Public keys are published at the JWKS endpoint (Ed25519).

Anonymous by construction.

Each service sees only a pairwise identifier — unique to your service, different for every audience. Two services can never link their users to each other, and no service ever learns the user's Planetary ID number, name, or any personal data — X-EGO stores none of it in the first place.

• Biometrics are processed on-device only (WebAuthn); nothing biometric is ever transmitted.
• The X-EGO database stores only an ID number and an irreversible hash of the passkey credential.
• The seen-users registry records only (audience, pairwise_id, first_seen).

When verification says no.

What it costs.

Per-tool prices (x402 pay-per-call)

Paid calls settle through the x402 payment protocol (v2). Calling a paid tool without payment returns an error whose _meta["x402/error"] carries the payment requirements (accepts) and step-by-step instructions; official x402 clients pay and retry automatically. Payment settles before the tool runs, and one payment authorizes exactly one execution — it cannot be reused. Invalid input (bad audience, malformed token, server-side ledger misconfiguration) is rejected for free, before any payment is taken.

Payments run on Base mainnet USDC (eip155:8453). Anonymous callers are rate-limited to 30 requests per minute per IP.

Pilot operator lane (free)

Registered pilot operators send their key as an Authorization: Bearer <key> HTTP header and call the paid tools free of charge during the pilot. Operator traffic is rate-limited to 300 requests per minute per key; no aggregate quota is currently enforced. Usage is metered per operator and endpoint — operators can read their own counters at GET /stats with the same key. Keys are issued manually — get in touch.

Connect an agent.

Add the MCP endpoint as a connector in any MCP-capable client. In Claude: Settings → Connectors → Add custom connector, then paste the endpoint URL:

https://mcp.x-ego.com/mcp

The three tools appear automatically. A minimal integration is three calls:

1. xego_request_proof_url({ audience: "your-domain.com" })
2. — user verifies at the returned URL and brings back a token —
3. xego_verify_proof({ token, expected_audience: "your-domain.com",
                       mark_as_seen: true })

← Back to x-ego.com