We scanned 26,302 x402 endpoints. 0.41% implement the protocol correctly.

ine |

Why this matters: The x402 compliance rate of 0.41% indicates that the infrastructure for autonomous agent commerce is not yet viable. If agents cannot verify payment endpoints cryptographically, autonomous transactions cannot occur safely. This finding enables a shift from ad-hoc security to standardized trust evidence. The existence of a byte-identical wire format across multiple implementations proves that language-agnostic trust is achievable, provided teams adopt rigorous canonicalization standards.

Core Solution

To bridge the trust gap, the industry requires a standardized, verifiable format for trust evidence that works across all agent frameworks and languages. The Composable Trust Evidence Format (CTEF) v0.3.1, frozen on April 24, 2026, addresses this by defining a strict wire format for trust claims.

CTEF relies on three core technical pillars:

1. RFC 8785 JSON Canonicalization Scheme (JCS): JSON serialization varies by language and library, leading to signature mismatches. JCS enforces deterministic serialization by sorting object keys, normalizing number representations, and removing whitespace. This ensures that a claim generated in Python produces the exact byte sequence as one generated in TypeScript.
2. Ed25519 Signatures via JWS RFC 7515: Ed25519 provides deterministic signatures with high security and fast verification. CTEF wraps these signatures in the JSON Web Signature (JWS) standard, enabling interoperability with existing cryptographic libraries.
3. Closed Claim Type Set: To prevent injection attacks and ambiguity, CTEF restricts claims to a closed set: {identity, transport, authority, continuity}. This enforces semantic consistency across implementations.

Validation of CTEF has been performed across eight independent implementations, including AgentGraph, APS, AgentID, @nobulex/crypto, HiveTrust, ArkForge Trust Layer, a clean-room canonicalizer, and Foxbook. Five Python canonicalizers, two TypeScript canonicalizers, and one reference implementation all produce byte-identical output against published test vectors. This confirms that RFC 8785 JCS is practical for cross-language trust verification.

Implementation Example

The following TypeScript example demonstrates how to construct and sign a CTEF envelope using RFC 8785 canonicalization and Ed25519. This implementation uses distinct interfaces and variable names to illustrate the pattern.

import { subtle } from 'crypto';
import { canonicalize } from 'rfc8785-jcs';
import { base64urlEncode } from './encoding-utils';

// Strict claim type enumeration
type CTEFClaimType = 'identity' | 'transport' | 'authority' | 'continuity';

interface TrustClaim {
    claim_type: CTEFClaimType;
    payload: Record<string, unknown>;
    issued_at: number;
}

interface CTEFEnvelope {
    claims: TrustClaim[];
    signature: string;
    issuer_kid: string;
    format_version: string;
}

class TrustEvidenceFabricator {
    private claims: TrustClaim[] = [];
    private formatVersion = 'CTEF_v0.3.1';

    addIdentityClaim(subject: string, did: string): void {
        this.claims.push({
            claim_type: 'identity',
            payload: { sub: subject, did: did },
            issued_at: Math.floor(Date.now() / 1000)
        });
    }

    addContinuityClaim(previousKeyId: string, rotationReason: string): void {
        this.claims.push({
            claim_type: 'continuity',
            payload: { prev_kid: previousKeyId, reason: rotationReason },
            issued_at: Math.floor(Date.now() / 1000)
        });
    }

    async sign(privateKey: CryptoKey): Promise<CTEFEnvelope> {
        // Sort claims deterministically by type then payload hash
        const sortedClaims = this.claims.sort((a, b) => {
            if (a.claim_type < b.claim_type) return -1;
            if (a.claim_type > b.claim_type) return 1;
            return JSON.stringify(a.payload).localeCompare(JSON.stringify(b.payload));
        });

        // Apply RFC 8785 JCS canonicalization
        const canonicalPayload = canonicalize(sortedClaims);
        
        // Sign with Ed25519
        const signatureBytes = await subtle.sign(
            'EdDSA',
            privateKey,
            new TextEncoder().encode(canonicalPayload)
        );

        return {
            claims: sortedClaims,
            signature: base64urlEncode(new Uint8Array(signatureBytes)),
            issuer_kid: 'key-1',
            format_version: this.formatVersion
        };
    }
}

// Usage
async function generateTrustEvidence() {
    const fabricator = new TrustEvidenceFabricator();
    fabricator.addIdentityClaim('agent-01', 'did:example:agent-01');
    
    // Generate Ed25519 keypair (simplified for example)
    const keyPair = await subtle.generateKey('EdDSA', true, ['sign', 'verify']);
    
    const envelope = await fabricator.sign(keyPair.privateKey);
    console.log('CTEF Envelope:', JSON.stringify(envelope, null, 2));
}

Architecture Rationale:

• JCS Canonicalization: Chosen to eliminate serialization drift. Without JCS, a Python agent and a TypeScript agent would generate different byte sequences for the same logical claim, causing signature verification failures.
• Ed25519: Selected for deterministic signatures and performance. Unlike RSA, Ed25519 does not require random padding, reducing the risk of implementation errors.
• Closed Claim Set: Enforces semantic boundaries. Allowing arbitrary claim types would enable malicious agents to inject unexpected data, breaking verification logic.
• Continuity Claims: Essential for key rotation. When an agent rotates its signing key, a continuity claim links the new key to the previous one, maintaining trust continuity without requiring re-verification of all historical claims.

Pitfall Guide

1. Non-Deterministic JSON Serialization

   • Explanation: Using standard JSON.stringify without canonicalization results in variable key ordering and whitespace, causing signature mismatches across languages.
   • Fix: Always use an RFC 8785 compliant canonicalizer before signing. Verify byte-identity against test vectors.

2. Ignoring Claim Type Constraints

   • Explanation: Allowing arbitrary claim types opens the door to injection attacks and semantic ambiguity.
   • Fix: Enforce the closed set {identity, transport, authority, continuity} at the schema validation layer. Reject any claim with an unknown type.

3. Key Rotation Without Continuity

   • Explanation: Rotating keys without issuing a continuity claim breaks the trust chain, forcing consumers to re-verify all historical evidence.
   • Fix: Always issue a continuity claim during rotation that references the previous key ID and rotation reason.

4. Clock Skew in Verification

   • Explanation: Agents may have unsynchronized clocks, causing valid claims to be rejected due to timestamp drift.
   • Fix: Implement a tolerance window (e.g., ±5 minutes) during timestamp verification. Log warnings for significant drift.

5. x402 Header Omission

   • Explanation: Failing to include the spec-required header in x402 responses renders the endpoint non-compliant, blocking agent payments.
   • Fix: Implement middleware that automatically injects the x402 header for all payment-related routes. Validate header presence in integration tests.

6. Multi-Language Drift

   • Explanation: Assuming that different language implementations produce identical output without explicit testing.
   • Fix: Run cross-language byte-match tests against published CTEF fixtures. Include these tests in CI/CD pipelines.

7. EU AI Act Non-Compliance

   • Explanation: Failing to produce machine-checkable audit logs for high-risk AI systems, risking regulatory penalties after August 2, 2026.
   • Fix: Integrate CTEF to generate cryptographic audit trails. Ensure logs are immutable and verifiable by third parties.

Production Bundle

Action Checklist

• Audit all x402 endpoints to ensure spec-required headers are present and valid.
• Implement RFC 8785 JCS canonicalization in all agent services generating trust evidence.
• Rotate signing keys using continuity claims to maintain trust chain integrity.
• Validate implementations against CTEF v0.3.1 test vectors to ensure byte-identity.
• Prepare for EU AI Act enforcement by integrating cryptographic audit logs by August 2, 2026.
• Scan npm and PyPI dependencies for critical vulnerabilities and remediate high-severity findings.
• Enforce closed claim type sets in all trust verification middleware.
• Conduct cross-language byte-match testing for Python and TypeScript implementations.

Decision Matrix

Scenario	Recommended Approach	Why	Cost Impact
High-Risk EU Deployment	CTEF + JCS	Mandatory cryptographic audit logs for compliance	Low dev cost; high compliance value
Internal Agent Mesh	Custom JWT	Simpler implementation for closed environments	Low cost; limited interoperability
x402 Commerce Integration	x402 + CTEF	Required for secure agent-to-agent payments	Essential for revenue generation
Multi-Framework Ecosystem	CTEF v0.3.1	Ensures byte-identical trust across languages	Moderate dev cost; high trust value

Configuration Template

{
  "trust_layer": {
    "format_version": "CTEF_v0.3.1",
    "canonicalization": "RFC8785_JCS",
    "signature_alg": "Ed25519",
    "allowed_claim_types": ["identity", "transport", "authority", "continuity"],
    "verification": {
      "clock_skew_tolerance_seconds": 300,
      "max_chain_depth": 10
    },
    "x402_compliance": {
      "enabled": true,
      "header_injection": "middleware"
    },
    "audit_logging": {
      "enabled": true,
      "format": "cte",
      "retention_days": 365
    }
  }
}

Quick Start Guide

1. Install Dependencies: Add an RFC 8785 canonicalization library and Ed25519 signing library to your project.
2. Generate Key Pair: Create an Ed25519 key pair for signing trust evidence. Store the private key securely.
3. Construct Claims: Use the TrustEvidenceFabricator to add identity, transport, authority, or continuity claims as needed.
4. Sign and Verify: Sign the canonicalized payload and verify the signature against the public key. Test against published CTEF fixtures.
5. Deploy Middleware: Integrate trust verification middleware into your agent services to validate incoming claims and enforce compliance.