Value Stories
How protocol trust is validated. Each story names a gap in the Commerce Authorization Chain and the test that would close it.
Can agents communicate?
A2A + MCP — 5/8 tested. Three gaps remain in agent coordination and tool access.
Testing A2A multi-agent coordination. Agent A delegates to Agent B, but no test proves the chain completes. Silent failures between agents would go undetected in production.
End-to-end test proving two agents coordinate a task via JSON-RPC without message loss.
Multi-agent chain test passes with both agents completing their portion. Message delivery verified at each hop. Currently: no test exists.
Test passes but only checks Agent A sent the message — never verifies Agent B received and acted on it.
MCP tool access is positioned as equal to A2A in the protocol stack, but has zero contracts and zero test specs. Agents accessing tools via MCP are completely unverified.
Zod contract defining MCP tool access response shape, plus Tier 1 in-process test proving tool invocation works.
MCP tool access has a contract and a passing test. Agent retrieves tool result matching the contract schema. Currently: 3-line stub in docs, no engineering artifact.
Contract exists but test mocks the MCP server — proving the mock works, not the protocol.
Agent needs to find the right agent for a task. A2A Discovery works (L3), but capability matching has no spec. Discovery finds agents; nothing proves they can do the job.
Capability search test proving query returns agents with matching capabilities, not just any registered agent.
Search query for 'payment-processing' returns only agents with that capability. Agents without it excluded. Currently: TODO.
Search returns all registered agents regardless of capability. Caller filters client-side — the protocol proves nothing.
Can agents pay and settle?
Verifiable Intent + Payment + On-Chain — 1/16 tested. The commerce chain is almost entirely unverified.
Deploying agent commerce where agents spend money on behalf of users. Verifiable Intent has 6 protocols and zero tests. No proof that user authorization is captured correctly. An agent could exceed its mandate with no detection.
Intent capture test proving user authorization is cryptographically bound to agent key before any transaction.
Intent captured with delegation chain verifiable. Agent action without captured intent rejected. Currently: 0/6 protocols tested.
Intent 'captured' as a database record with no cryptographic binding. Tamperable, unforgeable, undiscoverable.
Agent creates a payment intent. Spending authority check is untested. Budget could be exceeded silently — the agent says it checked, nothing proves it did.
Spending authority test proving budget check runs before payment execution and rejects over-limit amounts.
Amount within budget passes. Amount exceeding budget rejected before payment reaches the settlement layer. Currently: TODO.
Budget check runs but only logs a warning — payment still executes. The check exists but doesn't enforce.
API provider requires payment for access. x402 handshake (HTTP 402 + stablecoin) has no contract, no spec. The entire micropayment flow for agent-to-agent API access is NOT STARTED.
x402 handshake contract + test proving HTTP 402 triggers stablecoin payment and grants access.
Server returns 402. Agent pays via stablecoin. Server grants access. Full round-trip verified. Currently: NOT STARTED.
Test mocks the 402 response and the stablecoin transfer. Proves nothing about real settlement.
Agent transaction requires escrowed funds on Sui. Escrow deposit is untested. Funds locked in a contract with no test proving they can be released — or that they can't be stolen.
Sui escrow deposit test on testnet proving funds lock correctly and release only on proof-of-work.
Funds deposited in escrow on Sui testnet. Withdrawal without proof rejected. Release with valid proof succeeds. Currently: TODO.
Test runs against a local Move simulator. Proves the logic, not the chain. Testnet = real nodes, real consensus.
Can we prove coverage?
Identity, oversight, attestation, and computation — the meta-layer that proves the other layers work.
High-value agent transaction needs identity verification. FIDO binding has no contract, no spec. The 'right human authorized this' claim is undocumented and untested.
Identity binding test proving FIDO credential verifies the correct human before agent action proceeds.
Valid FIDO credential passes. Invalid credential rejected. Action without credential blocked. Currently: NOT STARTED.
Test uses a software FIDO emulator. Proves the emulator works, not the protocol binding.
Checking protocol coverage status. Open PROTOCOL-COVERAGE.md, count rows manually. 49 rows across 5 tables. Count changes every sprint. Number in the summary section may not match the tables.
Script that reads test results and computes coverage percentage per domain automatically.
Run script. Output: Domain 1: 5/8 (63%), Domain 2: 0/6 (0%), ... Total: 20/49 (41%). Matches reality. Currently: hand-counted.
Script counts files in the test directory. File existing is not the same as test passing.
High-value irreversible transaction. Human-in-the-Loop oversight is documented in the trust architecture but untested. If the escalation path doesn't work, the safety net has a hole.
HITL test proving high-value transactions trigger human approval and block execution until approved.
Transaction above threshold pauses. Human approves. Transaction proceeds. Human rejects. Transaction cancelled. Currently: TODO.
Approval prompt fires but transaction executes regardless of response. The UI shows oversight; the system ignores it.
Agent completes a transaction. On-chain attestation should record the action as a tamper-proof audit trail. No contract validates the attestation structure. Claims of immutability are unverified.
On-chain attestation test proving agent action is recorded on-chain and cannot be modified after recording.
Attestation written to Sui. Read-back matches. Modification attempt fails. Audit trail intact. Currently: TODO.
Attestation written to a database table labeled 'on-chain'. Not on any chain. Not tamper-proof. Just a table.
After 60 days of active development, if protocol coverage has not moved from 41% to 60%, the contract-first approach is too slow. Switch to integration-test-only coverage or re-scope to Commerce Authorization Chain only.
Coverage by domain
| Domain | Current | Target |
|---|---|---|
| Agent Communication | 5/8 (63%) | 8/8 |
| Verifiable Intent | 0/6 (0%) | 4/6 |
| Payment Execution | 1/6 (17%) | 5/6 |
| Identity & Verification | 2/5 (40%) | 3/5 |
| On-Chain Trust | 0/4 (0%) | 3/4 |
| Total | 20/49 (41%) | 39/49 (80%) |
Questions
Which untested protocol would cause the most damage if it failed silently in a real transaction?
- Is contract-first testing faster or slower than writing specs first and deriving contracts?
- When Verifiable Intent requires FIDO keys, is the test proving the protocol or proving FIDO?
- If 80% coverage takes 60 days, is the remaining 20% worth another 60 or infinite?