This article provides a step by step guide to the A2A CLI, driven against Rust agents that speak A2A Protocol v1.0. The same Rust code, a Lucas-Lehmer test over the first N Mersenne prime exponents, is served three ways: on the official A2A Rust SDK, as a plain stdin/stdout program wrapped by a2a server --exec, and behind an ADK coordinator on Gemini started with the ADK CLI. Each one is timed from the A2A CLI and from a Rust client.

https://github.com/xbill9/rust-dev/tree/main/a2a-benchmark-rust

The A2A CLI talks to all three with the same commands, and a2a server --exec turns a 30-line program with no A2A code into an agent that ADK can call. One a2a send from a shell takes a median 20.74 ms against the SDK agent, of which 7.62 ms is starting the CLI. From a Rust client the SDK agent adds 0.55 to 1.40 ms per call, the wrapped program 3.33 to 5.05 ms, and the ADK coordinator a median 1328 ms on gemini-3.5-flash and 2283 ms on gemini-3.8-flash. Every call through N=26 returned the right count of primes.

What Is Being Built?

Agent Port How it speaks A2A
mersenne-agent 8104 Official Rust SDK, JSON-RPC at /jsonrpc and HTTP+JSON at /rest
mersenne-exec 8105 A stdin/stdout Rust program served by a2a server --exec
rust_bench 8106 ADK LlmAgent on Gemini, served by adk api_server --a2a
echo 8108 a2a server --echo, for the first command 
a2a CLI ──► adk api_server --a2a (:8106) ──Gemini──► RemoteA2aAgent ──► mersenne-agent (:8104)
                    rust_bench                                     └──► a2a server --exec (:8105) ──► mersenne-exec
                        └── run_benchmark tool ──► mersenne-bench ──► both Rust agents
Enter fullscreen mode Exit fullscreen mode

Versions, read from the machine on 2026-11-03:

Component Version
A2A protocol 1.0
A2A CLI (a2a) v0.3.1
a2a-lf / a2a-server-lf / a2a-client-lf 0.4.2 / 0.5.3 / 0.2.9
Rust 1.99.1, edition 2024
google-adk / a2a-sdk / google-genai 2.13.0 / 1.3.0 / 2.34.0
Model gemini-3.8-flash on Vertex AI

The a2a-*-lf crates are the official SDK from a2aproject/a2a-rs. Agent cards carry the protocol as Major.Minor, so they read 1.0.

Step 1 — Install the A2A CLI

The CLI is one Go binary. Homebrew, WinGet and release binaries work; from source:

go install github.com/a2aproject/a2a-cli@latest
mv "$(command -v a2a-cli)" "$(dirname "$(command -v a2a-cli)")/a2a"
a2a version
Enter fullscreen mode Exit fullscreen mode 
a2a v0.3.1
commit:  none
built:   unknown
go:      go1.26.3
os/arch: linux/amd64
Enter fullscreen mode Exit fullscreen mode

go install names the binary a2a-cli; the docs and the CLI's own skill call it a2a.

Step 2 — Talk to an Echo Server

a2a server --echo starts an agent that sends back what it receives, so the client can be checked before any agent code exists:

a2a server --echo --port 8108 &
a2a send -a http://localhost:8108 "hello world from A2A"
Enter fullscreen mode Exit fullscreen mode 
Task:     01a1a35f-2b2b-7f3a-92a2-e3dc6c69e359
Context:  01a1a35f-2b2c-7120-ac45-a74adab9d1d2
Status:   completed (2026-11-03T16:44:45-05:00)
Artifacts:
  [01a1a35f-2b2c-71ba-8e6c-22c4b7c210df] hello world from A2A
History:
  [user] hello world from A2A
Enter fullscreen mode Exit fullscreen mode

Every send creates a task with an id, a context, a final status and its artifacts. The Go servers started by the CLI stamp local time; the Rust SDK agent stamps UTC.

Step 3 — Build and Start the Rust Agents

The rig is one Cargo project with four binaries: the SDK agent, the stdin/stdout program, the benchmark client, and a shared library holding the Lucas-Lehmer code.

git clone https://github.com/xbill9/rust-dev
cd rust-dev/a2a-benchmark-rust
cargo build --release
scripts/start-all.sh
Enter fullscreen mode Exit fullscreen mode 
agents up: 8104 native, 8105 exec
Enter fullscreen mode Exit fullscreen mode

start-all.sh rebuilds, stops any running copy, starts the SDK agent on 8104 and a2a server --exec on 8105 with logs in logs/, and waits until both cards answer. scripts/test-cli.sh runs the CLI commands below against them and checks each reply.

Step 4 — Read an Agent Card

card get fetches /.well-known/agent-card.json and prints what the agent offers:

a2a card get -a http://localhost:8104
Enter fullscreen mode Exit fullscreen mode 
Name:         Mersenne Prime Agent Rust
Description:  A Rust A2A v1.0 agent (official a2a-rs SDK) that confirms the first n Mersenne primes with the Lucas-Lehmer test and reports the elapsed time.
Version:      0.1.0
Interfaces:
  JSONRPC (A2A v1.0)     http://localhost:8104/jsonrpc
  HTTP+JSON (A2A v1.0)   http://localhost:8104/rest
Streaming:    true
Skills:
  find-mersenne-rust   Find Mersenne Primes in Rust
Enter fullscreen mode Exit fullscreen mode

The card lists two interfaces. The CLI picks one, and --transport chooses.

Step 5 — Send, Stream, Switch Transport, Send Data

A plain message:

a2a send -a http://localhost:8104 "Calculate the first 12 Mersenne primes"
Enter fullscreen mode Exit fullscreen mode 
Status:   completed (2026-11-03T21:44:45Z)
  Found first 12 Mersenne primes in 0.0902ms.
Artifacts:
  [mersenne-report] Found first 12 Mersenne primes in 0.0902ms. {"elapsed_ms":0.090239,"exponents":[2,3,5,7,13,17,19,31,61,89,107,127],"found":12,"requested":12}
Enter fullscreen mode Exit fullscreen mode

The mersenne-report artifact carries two parts: the summary as text, and the same result as a data part, so a client reads the timing from a field.

--stream prints each event as it arrives, here the working status before the result:

a2a send -a http://localhost:8104 --stream "first 8"
Enter fullscreen mode Exit fullscreen mode 
[status] working
Task:     01a1a35f-2b64-77b5-9417-18b1f425b17d
Context:  01a1a35f-2b64-77b5-9417-18b24253b719
Status:   completed (2026-11-03T21:44:45Z)
  Found first 8 Mersenne primes in 0.0164ms.
Enter fullscreen mode Exit fullscreen mode

--transport rest sends the same request over HTTP+JSON, and --data-part sends structured input:

a2a send -a http://localhost:8104 --transport rest "first 4"
a2a send -a http://localhost:8104 --data-part '{"count": 6}'
Enter fullscreen mode Exit fullscreen mode 
  Found first 4 Mersenne primes in 0.0080ms.
  Found first 6 Mersenne primes in 0.0108ms.
Enter fullscreen mode Exit fullscreen mode

🔎 Tip: Data Parts Arrive as Floats

A2A v1.0 carries data parts as a protobuf Struct, whose only number type is a double. {"count": 6} sent by the CLI reaches the agent as 6.0, so a strict integer field fails to deserialise. Read numbers with as_f64 and check for a whole value:

if let PartContent::Data(v) = &part.content
    && let Some(n) = v.get("count").and_then(|n| n.as_f64())
    && n >= 1.0
    && n.fract() == 0.0
{
    return n as usize;
}
Enter fullscreen mode Exit fullscreen mode

Step 6 — Script It With JSON Output

-o json prints the whole task, which pipes into anything:

a2a send -a http://localhost:8104 -o json 'first 3' | python3 -c 'import sys,json; t=json.load(sys.stdin)["task"]; print(t["status"]["state"], [p for a in t["artifacts"] for p in a["parts"] if "data" in p][0]["data"])'
Enter fullscreen mode Exit fullscreen mode 
TASK_STATE_COMPLETED {'elapsed_ms': 0.007166, 'exponents': [2, 3, 5], 'found': 3, 'requested': 3}
Enter fullscreen mode Exit fullscreen mode

Step 7 — Tasks: List, Start in the Background, Wait

The SDK agent keeps its tasks in memory, and the CLI reads them back:

a2a task list -a http://localhost:8104
Enter fullscreen mode Exit fullscreen mode 
ID                                    STATUS     CONTEXT
01a1a35f-2b4f-7190-b6df-81bb7b76c2cc  completed  01a1a35f-2b4f-7190-b6df-81bca35e8b6d
01a1a35f-2b64-77b5-9417-18b1f425b17d  completed  01a1a35f-2b64-77b5-9417-18b24253b719
01a1a35f-2bab-7012-b094-1022dce75f36  completed  01a1a35f-2bab-7012-b094-1023824b35eb
Enter fullscreen mode Exit fullscreen mode

--async returns as soon as the task exists. N=25 takes over a second, long enough to catch it running:

a2a send -a http://localhost:8104 --async "first 25"
Enter fullscreen mode Exit fullscreen mode 
Task:     01a1a3f5-9da1-746b-abae-84307e4e1735
Context:  01a1a3f5-9da1-746b-abae-8431b422e72e
Status:   working (2026-11-04T00:29:05Z)
History:
  [user] first 25
Enter fullscreen mode Exit fullscreen mode

task get --wait polls until the task finishes:

a2a task get -a http://localhost:8104 01a1a3f5-9da1-746b-abae-84307e4e1735 --wait --poll-interval 500ms
Enter fullscreen mode Exit fullscreen mode 
Task:     01a1a3f5-9da1-746b-abae-84307e4e1735
Context:  01a1a3f5-9da1-746b-abae-8431b422e72e
Status:   completed (2026-11-04T00:29:06Z)
  Found first 25 Mersenne primes in 1509.7683ms.
Enter fullscreen mode Exit fullscreen mode

Step 8 — The Native Rust Agent

The SDK agent is one AgentExecutor. It emits a working status, runs the big-integer work on a blocking thread, then returns the finished task:

let done = async move {
    // Big-integer work is CPU-bound; keep it off the async workers.
    let report = tokio::task::spawn_blocking(move || find_mersenne_primes(count))
        .await
        .map_err(|e| A2AError::internal(format!("worker panicked: {e}")))?;
    let summary = report.summary();
    let data = serde_json::to_value(&report)
        .map_err(|e| A2AError::internal(format!("serialise report: {e}")))?;
    // ... Task { status: Completed, artifacts: [Part::text(summary), Part::data(data)] }
};
Box::pin(stream::once(async { Ok(working) }).chain(stream::once(done)))
Enter fullscreen mode Exit fullscreen mode

The server wires the SDK's routers into axum, one per transport plus the card:

let handler = Arc::new(DefaultRequestHandler::new(MersenneExecutor, InMemoryTaskStore::new()));
let card = Arc::new(StaticAgentCard::new(agent_card(&base)));

let app = axum::Router::new()
    .nest("/jsonrpc", a2a_server::jsonrpc::jsonrpc_router(handler.clone()))
    .nest("/rest", a2a_server::rest::rest_router(handler))
    .merge(a2a_server::agent_card::agent_card_router(card));
Enter fullscreen mode Exit fullscreen mode

The Lucas-Lehmer test runs on num-bigint with the reduction mod 2^p − 1 done by folding the high bits onto the low ones. The timed region holds only the tests, on a monotonic clock, and no prime is ever turned into a decimal string. Two slow tests check the arithmetic: one runs the test on every prime exponent up to 9941 and asserts it accepts exactly the first 22 known ones, the other confirms all 26:

cargo test --release --lib -- --ignored
Enter fullscreen mode Exit fullscreen mode 
test tests::all_26_exponents_prime ... ok
test tests::exhaustive_through_n22 ... ok

test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 5 filtered out; finished in 25.70s
Enter fullscreen mode Exit fullscreen mode

Step 9 — Serve a Plain Program With a2a server --exec

mersenne-exec knows nothing about A2A. It reads the message on stdin and prints two lines:

echo 'first 5' | target/release/mersenne-exec
Enter fullscreen mode Exit fullscreen mode 
{"requested":5,"found":5,"elapsed_ms":0.007023000000000001,"exponents":[2,3,5,7,13]}
Found first 5 Mersenne primes in 0.0070ms.
Enter fullscreen mode Exit fullscreen mode

The A2A CLI makes it an agent:

a2a server --exec "$PWD/target/release/mersenne-exec" --chunk=$'\n' \
  --name "Mersenne Prime Exec Rust" \
  --advertise-address "http://localhost:8105" --port 8105
Enter fullscreen mode Exit fullscreen mode

The same client commands work against it:

a2a send -a http://localhost:8105 --stream "first 8"
Enter fullscreen mode Exit fullscreen mode 
Status:   submitted
History:
  [user] first 8
[status] working
[artifact] {"requested":8,"found":8,"elapsed_ms":0.01543,"exponents":[2,3,5,7,13,17,19,31]}Found first 8 Mersenne primes in 0.0154ms.
[status] completed
Enter fullscreen mode Exit fullscreen mode

The exec server starts the program once per message, hands it the text, and returns stdout as the artifact.

🔎 Tip: Two --exec Flags ADK Needs

  • --advertise-address http://localhost:8105. The exec server's card names 127.0.0.1 by default, and ADK's RemoteA2aAgent refuses a card whose RPC URL has a different origin from the one the card came from.
  • --chunk=$'\n'. With it, each output line streams as its own chunk. Without it, stream requests get UNSUPPORTED_OPERATION: the Go CLI falls back to polling and ADK's Python client fails. ADK keeps only the last chunk, so mersenne-exec prints the JSON line first and the summary last.

Step 10 — Put ADK in Front

ADK needs its Python package and Gemini on Vertex AI, signed in with application-default credentials:

pip install -U "google-adk[a2a]"
gcloud auth application-default login
source scripts/adk-env.sh
Enter fullscreen mode Exit fullscreen mode

adk-env.sh sets GOOGLE_GENAI_USE_VERTEXAI=TRUE, GOOGLE_CLOUD_LOCATION=global, the project, and MODEL_NAME, which defaults to gemini-3.8-flash.

adk/rust_bench/agent.py is an ADK LlmAgent with both Rust agents as RemoteA2aAgent sub-agents and one tool:

native_agent = RemoteA2aAgent(
    name="native_rust_agent",
    description="Rust A2A v1.0 agent on the official a2a-rs SDK. ...",
    agent_card=f"{NATIVE_URL}{AGENT_CARD_WELL_KNOWN_PATH}",
)

root_agent = LlmAgent(
    name="rust_bench",
    model=os.getenv("MODEL_NAME", "gemini-3.8-flash"),
    tools=[run_benchmark],
    sub_agents=[native_agent, exec_agent],
)
Enter fullscreen mode Exit fullscreen mode

The ADK CLI runs it three ways:

adk run rust_bench                                # terminal
adk web --port 8107                               # dev UI
adk api_server --a2a --port 8106 adk              # A2A server, from the rig root
Enter fullscreen mode Exit fullscreen mode

adk api_server --a2a serves each agent folder that holds an agent.json card, at /a2a/<name>; scripts/start-adk.sh starts it in the background. The A2A CLI then treats the coordinator like any other agent:

a2a send -a http://localhost:8106/a2a/rust_bench/.well-known/agent-card.json \
  --timeout 120s "Find the first 9 Mersenne primes with the exec agent"
Enter fullscreen mode Exit fullscreen mode 
Status:   completed (2026-11-03T21:44:51Z)
Artifacts:
  [f2d2f27d-24ce-4120-8368-d966c99617a9] Found first 9 Mersenne primes in 0.0236ms.
History:
  [user] Find the first 9 Mersenne primes with the exec agent
  [agent] {"args":{"agent_name":"exec_rust_agent"},"id":"call_1332004","name":"transfer_to_agent"}
  [agent] {"id":"call_1332004","name":"transfer_to_agent","response":{"result":null}}
  [agent] {"requested":9,"found":9,"elapsed_ms":0.023635,"exponents":[2,3,5,7,13,17,19,31,61]}
  [agent] Found first 9 Mersenne primes in 0.0236ms.
Enter fullscreen mode Exit fullscreen mode

The history shows the hand-off: Gemini calls transfer_to_agent, the Rust agent answers, and its JSON report comes back through two A2A hops.

Step 11 — Keep the Model Away From the Numbers

A benchmark through an LLM can time the model writing a number. Two rules keep the timing in code:

  • The benchmark client checks every reply. mersenne-bench reads the timing from the agent's data part or JSON line, rejects a report where requested differs from N or found differs from min(N, 26), and rejects an LLM-path reply with no transfer_to_agent to a Rust agent. Each row records where its report came from and who it was routed to.
  • ADK benchmarks go through a tool. run_benchmark runs mersenne-bench and returns medians already computed and rounded. The instruction tells Gemini to quote them, and scripts/check-adk-reply.py verifies a reply: one run_benchmark call, with the arguments asked for, and every number in the answer a value the tool returned.

A benchmark request sent from the CLI, saved with -o json. The tool call and the head of the answer:

a2a send -a $CARD --timeout 300s -o json "Benchmark both agents for N=3 to 6 with 2 reps" > reply.json
Enter fullscreen mode Exit fullscreen mode 
[tool call] {"max_n": 6, "min_n": 3, "reps": 2}
### Arguments Used
- `min_n`: 3
- `max_n`: 6
- `reps`: 2
Enter fullscreen mode Exit fullscreen mode

The answer goes on with a summary per agent and a row per N. The check:

scripts/check-adk-reply.py reply.json 3 6 2
Enter fullscreen mode Exit fullscreen mode 
state: TASK_STATE_COMPLETED
run_benchmark calls: 1
args sent: {'max_n': 6, 'min_n': 3, 'reps': 2}  requested: {'min_n': 3, 'max_n': 6, 'reps': 2}
numbers in reply: 57  not from the tool: 0
PASS
Enter fullscreen mode Exit fullscreen mode

scripts/adk-reliability.sh sends ten benchmark requests with varied ranges and ten requests that name no agent. On gemini-3.8-flash, 10 of 10 benchmark replies passed the checker and 10 of 10 unnamed requests went to native_rust_agent.

The sweep covers the whole exponent table, N=1 to 26. Exponent 23209 is a 6,987-digit number, and the arithmetic stays in BigUint throughout.

Step 12 — Benchmark From a Rust Client 

REPS=20 scripts/bench.sh          # native + exec, N=1..26
ADK=1 REPS=3 scripts/bench.sh     # adds the ADK series
Enter fullscreen mode Exit fullscreen mode

mersenne-bench is built on the SDK's client crate, a2a-client-lf. Each call records the agent's own compute time and the client's round trip; overhead is the round trip minus compute, per call. Direct calls, medians of 20 reps:

N native compute ms native overhead ms exec compute ms exec overhead ms
1 0.001039 0.731 0.0004555 4.046
10 0.04249 0.793 0.04200 4.391
20 26.33 0.970 60.21 4.374
22 181.1 1.255 264.6 3.558
24 781.1 1.073 868.9 3.335
26 2484 1.396 2619 3.588

Through ADK, medians of 3 reps, one run per model. All 26 rows in each run went to native_rust_agent and read its data part:

N 3.5-flash compute ms 3.5-flash round trip ms 3.8-flash compute ms 3.8-flash round trip ms
1 0.002051 1665.053 0.002615 2073.666
10 0.04513 1394.245 0.04390 2458.155
20 72.95 1332.994 68.52 2336.569
22 279.8 1868.178 287.3 2679.324
26 2226 3455.492 2241 4123.353

The slowest single call on gemini-3.8-flash took 29.0 s, at N=9.

Step 13 — Time the A2A CLI Itself

scripts/cli-bench.py runs one a2a send -o json process per call, the way a shell script would, and applies the same checks to each reply. Wall time covers starting the CLI, fetching the card, sending, and exiting. Two reference commands, 20 runs each:

Command Median ms Min ms Max ms
a2a version 7.17 5.57 9.62
a2a card get (native) 9.18 8.30 11.17

The full sweep, N=1 to 26, 5 reps direct and 3 through ADK:

Agent Calls Overhead per call, per-N medians Median of the per-N medians
native 130 10.92 to 21.82 ms 20.28 ms
exec 130 9.43 to 20.81 ms 17.51 ms
ADK, 3.8-flash 78 1825.22 to 3017.92 ms 2217.55 ms

Every ADK call went to native_rust_agent; the slowest took 22693.6 ms. The sweep times each agent in its own block, so native and exec ran minutes apart. Run in alternating order, N=1, 30 runs each (scripts/cli-transport.py):

native, default (JSON-RPC): median 20.74 ms, min 18.60, max 26.51
native, --transport rest: median 21.49 ms, min 19.63, max 26.15
exec (HTTP+JSON only): median 20.81 ms, min 18.67, max 28.07
a2a version: median 7.62 ms, min 6.07, max 10.71
Enter fullscreen mode Exit fullscreen mode

From a shell, the transport and the serving path make no difference to the CLI's cost: about 21 ms per call, about a third of it starting the process. Against the Rust client's 0.55 to 1.40 ms, the CLI fits scripts and checks, and the Rust client fits a benchmark.

The CLI's overhead in the sweep drops to about 11 ms for both agents once compute passes 100 ms (N=21 and up). Why is untested.

🔎 Tip: Compare Compute Only Between Runs Paced Alike

The same native process at N=20 takes 26.07 ms when calls arrive back to back and 68.09 ms when each call follows a 1.3 s idle gap (mersenne-bench --gap-ms 1300). ADK's model round trip spaces calls out too, and its mid-range compute times sit close to the gap series: 68.52 ms at N=20 on gemini-3.8-flash. The CPU-level cause, clock scaling or core placement on a hybrid laptop CPU, is untested.

Compare and Contrast

Serving path Code the agent needs Overhead from a Rust client a2a send from a shell, N=1
Official Rust SDK 🥇 an AgentExecutor and three routers 0.55 to 1.40 ms 20.74 ms
a2a server --exec 🥈 none: stdin in, stdout out 3.33 to 5.05 ms 20.81 ms
ADK coordinator 🥉 an agent.py, an agent.json card 1328 ms on 3.5-flash, 2283 ms on 3.8-flash 2664.00 ms on 3.8-flash

Rust-client ranges are the smallest and largest per-N medians; the ADK figures are the medians of its per-N medians. The exec figure includes starting a process for every message; how it splits between process start and the HTTP hop was not measured. At N=26 the work itself dominates every path: 2484 ms native and 2619 ms exec, direct.

So, Which One?

For an agent built to be one, use the SDK: about a millisecond of protocol cost, both transports, tasks the CLI can list and wait on.

For a program that already exists, a2a server --exec makes it an agent with no code change. A few milliseconds per call buys that, and ADK can call it once the two flags are set.

For routing by natural language, put ADK in front and keep the timing out of the model: a tool for anything computed, and a check that the model sent the arguments asked for.

For talking to any of them, the A2A CLI is the one client: card get, send, --stream, task get --wait, and -o json for scripts. Each call costs about 21 ms, so time agents from a long-lived client.

Summary

The goal of this article was to drive the A2A CLI against Rust agents on A2A v1.0, and to measure what each way of serving the same Rust code costs per call. The key to the solution was one benchmark client that reads timing from a structured report and checks that every reply answers the question asked. The results on one laptop were:

  • 🟢 The A2A CLI drove all three agents with the same commands: card, send, stream, REST, data parts, JSON output, task list, --async and task get --wait
  • 🟢 Every call through N=26, from the Rust client and from the CLI, reported found = min(N, 26)
  • 🟢 The SDK agent added 0.55 to 1.40 ms per call from a Rust client
  • 🟢 a2a server --exec served an A2A-unaware program to the CLI and to ADK
  • 🟢 On gemini-3.8-flash, 10 of 10 benchmark replies quoted only tool values, and 10 of 10 unnamed requests went to the native agent
  • ⚠️ One a2a send from a shell costs about 21 ms whatever the agent, 7.62 ms of it starting the CLI
  • ⚠️ The wrapped program added 3.33 to 5.05 ms per call from a Rust client
  • ⚠️ ADK added a median 1328 ms per call on gemini-3.5-flash and 2283 ms on gemini-3.8-flash, with one call at 29.0 s
  • ❌ Compute times from calls spaced by idle gaps run slower and do not compare with back-to-back runs

Scope: one 13th Gen Intel Core i7-1360P laptop on Linux, release build, every agent and client on the same machine, 2026-11-03 and 2026-11-04. Rust-client series have 20 reps per N direct and 3 through ADK, with one run per model on Vertex AI's shared global endpoint, so the difference between the two Gemini models is a single sample. The CLI series has 5 reps per N direct and 3 through ADK, on gemini-3.8-flash only, and reliability was checked on that model only, ten requests of each kind. The gRPC transport, task cancel, task subscribe, push notifications and authentication were not exercised.

The strategy for serving and benchmarking Rust A2A agents with the A2A CLI was validated with an incremental step by step approach.

References