Agent-to-agent protocols are easy to demo and hard to operate. A single successful message/send against a happy-path server tells you almost nothing about whether your agent will survive a coordinator, a retry, a cold container, or an LLM that decides to summarize your numeric output.
A recent Dev.to walkthrough offers a useful stress pattern: the same Rust workload — a Lucas–Lehmer test over the first N Mersenne prime exponents — served three different ways, then driven from the same A2A CLI. Path one is the official A2A Rust SDK. Path two is a plain stdin/stdout program with no protocol code at all, wrapped by a2a server --exec. Path three sits behind an ADK coordinator on Gemini, launched with the ADK CLI. Identical business logic, three different shells.
That isolation is the whole point. When the only variable is the serving layer, every difference in behavior, latency, or output shape is a protocol or integration defect — not a product decision. Below is the checklist we would use to gate that kind of release.
Why one workload in three shells is the honest test

Figure: Editorial context image from the source page (preview only; rights remain with the publisher) · Credit / further reading: dev.to
Most agent interoperability failures are not protocol failures. They are boundary failures: a banner printed to stdout, a task marked completed when it actually errored, an agent card that advertises streaming the server does not implement, a coordinator that paraphrases a result and silently changes a digit.
Serving one deterministic function through three shells forces each of those boundaries into view. The exec path is especially underrated. If a 30-line program that reads stdin and writes stdout can be turned into a spec-compliant agent without importing an SDK, then your protocol boundary is thin and legible. If it cannot, every future agent you ship inherits hidden coupling.
The pre-flight checklist
Use pass/fail, not a score. A single fail on items 1, 5, or 6 should block release outright.
1. Deterministic workload behind every shell
Pass: the same input produces byte-identical output through the SDK, the exec wrapper, and the coordinator. Fail: the coordinator reformats, rounds, or summarizes the payload; or the exec path returns a different shape than the SDK path.
2. The agent card matches observable behavior
Pass: skills, capabilities, streaming support, and auth schemes on the card are generated from or tested against the running server. Fail: the card is hand-maintained and drifts after the first refactor.
3. Both message/send and streaming paths work
Pass: the streaming path emits incremental updates and a terminal event, and the final assembled result equals the non-streaming result. Fail: streaming returns a single blob at the end, or drops the terminal state.
4. Task states are real, not decorative
Pass: submitted, working, input-required, completed, failed, and canceled are reachable where appropriate, and cancellation actually stops work. Fail: errors are returned as completed with error text inside the payload — the single most common integration bug in agent systems.
5. stdout is a protocol channel, not a log
Pass: the exec-wrapped binary writes only protocol JSON to stdout, sends all logs to stderr, flushes on every message, and uses exit codes that the wrapper can interpret. Fail: a startup banner, a progress bar, or a debug print lands in the stream and corrupts framing.
6. The coordinator delegates instead of editorializing
Pass: the coordinator forwards the task, passes the result through unchanged, and any summarization is clearly a separate, labeled step. Fail: an LLM coordinator rewrites numbers, drops fields, or claims success the downstream agent never reported.
Parity, timing, and the numbers that lie

Figure: HEXOPS original illustration inspired by the topic (not a copy of the source article imagery) · Credit / further reading: dev.to
7. Measure from two clients, always
Pass: latency is captured from the A2A CLI and from a native client, with p50 and p95 recorded per path. Fail: only end-to-end wall-clock is reported, so nobody can tell whether time went into transport, the wrapper, the model, or the workload.
8. Cold start is a first-class metric
Pass: cold-start time is measured separately from warm throughput, and the exec path is compared against the SDK path at the same temperature. Fail: a warm SDK server is benchmarked against a cold process spawn, and the resulting table is presented as a protocol comparison.
9. Failure drills are scripted
Pass: the team can reproduce timeout, malformed input, mid-stream disconnect, duplicate delivery, and cancellation — and each produces the correct terminal state. Fail: failure handling is left to manual exploration the week before launch.
10. Auth and tenancy are enforced at the boundary
Pass: every path rejects unauthenticated calls, scopes tokens per tenant, and the agent card declares the scheme it actually enforces. Fail: the exec wrapper inherits ambient local trust and is deployed as if it were authenticated.
11. Traces cross every hop
Pass: a trace or correlation ID injected by the client appears in the wrapper logs, the SDK agent, and the coordinator transcript. Fail: debugging a coordinator failure means correlating timestamps by hand.
12. A contract gate runs in CI
Pass: schema validation, agent card checks, and a minimal send/stream/cancel suite run on every commit against all three serving paths. Fail: interoperability is verified by a demo, not by a pipeline.
The release scorecard
A build ships when items 1–6 pass on all three paths, items 7–8 have recorded baselines you are willing to defend, and items 9–12 are automated rather than aspirational. Anything else is a demo with a deployment pipeline attached.
The deeper lesson from the three-shell pattern is architectural: keep protocol concerns in a thin adapter and keep your actual work in a program that knows nothing about agents. Then the SDK is a convenience, the exec wrapper is a fallback, and the coordinator is a consumer — not a rewrite.
Key takeaways
- One deterministic workload across three serving paths isolates protocol defects from product behavior.
a2a server --execis a legitimate production path, but only if stdout stays clean and logs go to stderr.- Treat
completedwith an error string as a release blocker. - Benchmark cold and warm separately, from the CLI and from a native client.
- A coordinator that alters downstream results is a correctness bug, not a UX feature.
- Automate contract tests across all paths, or interoperability is a claim rather than a property.
Next steps
- Pick one deterministic function in your codebase and expose it through all three paths this sprint.
- Write the send/stream/cancel contract suite before writing the adapter.
- Add a stdout-cleanliness test to CI: assert the exec binary emits only valid JSON frames.
- Record p50/p95 baselines for cold and warm runs and store them alongside the release.
- Run the five failure drills and file every mismatch as a bug against the serving layer, not the workload.



