This is a submission for the GitHub Finish-Up-A-Thon Challenge

Cross Language A2A Agent Benchmarking with Gemini 3 and Antigravity CLI

Building a Benchmarking Agent with A2A and MCP

This tutorial aims to build and test benchmarking Agents using the A2A protocol across several popular programming languages. The Master Orchestrator Agent is exposed via MCP to allow Antigravity CLI to be used as a MCP client.

Deja Vu — What is Old is New

This paper is a re-visiting of the original benchmark series with Gemini CLI over Node, GO, and Python:

Cross Language A2A Agent Benchmarking with Gemini 3 and Gemini CLI

_Building a Benchmarking Agent with A2A and MCP_medium.com

In this updated version, the Antigravity CLI is used over Node, GO, Python, and Rust.

Why would I need Multi-Language Support? Can’t I just use Python?

Most mature Agent development tools and libraries are Python based. Python allows for rapid prototyping and evaluation of approaches. Python is also an interpreted language- which has trade-offs in memory safety, and performance. Other languages like GO and Rust offer high performance and memory safe operations. With a language neutral communication protocol — the actual Agent implementation of each Agent can be coded in the most appropriate language.

What is this Approach actually Benchmarking?

The high level goal was to measure the actual time spent running an algorithm in the native language code inside the A2A agent. Each language had a slightly different implementation due to the language syntax. After running the algorithm- each Agent was instructed to calculate and return the elapsed time for cross language comparison.

What is the Agent Development Kit?

The Agent Development Kit (ADK) is a flexible and modular framework for developing and deploying AI agents. While optimized for Gemini and the Google ecosystem, ADK is model-agnostic, deployment-agnostic, and is built for compatibility with other frameworks. The official ADK is only currently available in the Python, GO, and Java programming languages.

Google’s Agent Stack in Action: ADK, MCP, A2A on Google Cloud

Google provides full documentation on the Agent Development Kit (ADK) here:

Agent Development Kit

_Build powerful multi-agent systems with Agent Development Kit_google.github.io

What is the A2A protocol?

The Agent2Agent (A2A) protocol, an open communication standard for AI agents, was initially introduced by Google in April 2025. It is specifically engineered to facilitate seamless interoperability within multi-agent systems, enabling AI agents developed by diverse providers or built upon disparate AI agent frameworks to communicate and collaborate effectively.

A good overview of the A2A protocol can be found here:

A2A Protocol

_The official documentation for the Agent2Agent (A2A) protocol. The A2A protocol is an open standard that allows…_a2a-protocol.org

Language Support For the A2A Protocol

The official ADK for Python, GO, and Java provide built-in support for working with the A2A protocol. For other programming languages like JS, Rust, and .NET — 3rd party libraries are available to add support for the protocol.

The main source for A2A Language support is the GitHub repo:

GitHub — a2aproject/A2A: An open protocol enabling communication and interoperability between…

_An open protocol enabling communication and interoperability between opaque agentic applications. — a2aproject/A2A_github.com

Tool Chain Setup for A2A

This article targets the Python, GO, Rust, and JavaScript environments.

The build tools for each language environment need to be in place. For building with Python- a working Python environment with 3.12 or later along with package management tools like uv or pip is required.

For building with GO — a recent version of the GO compiler (1.24.1 or later) is required.

For building with Rust, the Rust tool chain is required.

For building with Node / JavaScript — a working Node.js environment with Node version 20 or later and a functional npm tool is needed.

Antigravity CLI

Antigravity CLI is the follow-on successor to Gemini CLI- the terminal driven, agent assisted coding tool.

Full details on installing Antigravity CLI are here:

Getting Started with Antigravity CLI

_This article covers the initial setup and configuration for the Antigravity CLI on a stock Linux Environment._medium.com

Testing the Antigravity CLI Environment

Once you have all the tools in place- you can test the startup of Antigravity CLI.

You will need to authenticate with a Google Cloud Project or your Google Account:

agy

This will start the interface:

Checking the Developer Environment

Verify that all the prerequisite packages and compilers are installed — and clone the sample Github repo:

Once you have your Google Cloud Project and preferred authentication method — run the init.sh script to validate the setup:

The set_env.sh script is provided to set common ADK environment variables:

Debugging API Permission Errors

If your application default credentials expires or your Google Cloud Authentication expires you will get an error. The workaround is to re-authenticate:

Another common error is that the environment variables are not set correctly. Go the the root directory and re-run the set_env.sh to set the variables:

A2A Debugging Tools -A2A Inspector

The A2A Inspector is a standalone tool that provides low level visibility into the A2A protocol. The GitHub is available here:

GitHub — a2aproject/a2a-inspector: Validation Tools for A2A Agents

_Validation Tools for A2A Agents. Contribute to a2aproject/a2a-inspector development by creating an account on GitHub._github.com

A summary of the features of the A2A inspector can be found here:

A2A Protocol Documentation

_Documentation for A2A Protocol_a2aprotocol.ai

To install the A2A Inspector:

Then follow the build instructions — you need uv, and a recent version of node:

a2a-inspector/README.md at main · a2aproject/a2a-inspector

_Validation Tools for A2A Agents. Contribute to a2aproject/a2a-inspector development by creating an account on GitHub._github.com

Staring the A2A Inspector

Once the A2A inspector has been installed- you can validate the installation by using this URL:

http://127.0.0.1:5001/

Extending ADK Agents with A2A

The ADK provides several key tools to allow standard ADK Agents to run as standalone A2A agents — without the ADK — either in A2A Client or A2A Server mode. The Python ADK includes libraries and samples to extend a standard ADK agent to enable A2A protocol features. Instead of running the agent inside the ADK web utility- the agents are dual purposed with A2A to be able to run as dedicated agents with their own embedded Uvicorn web server.

I am confused- How Does this all Work?

When Agents are run in ADK mode — the ADK CLI or Web interface is used to directly interact with the Agents. The ADK UI is started in a well known port — usually 8000 and the Agents are accessed in that environment.

The ADK does not automatically expose the agent as an A2A agent. The basic agent code from the ADK needs to be extended and enabled to run as a standalone A2A Agent. Without the additional A2A function calls and a active standalone web server- the Agents will not be usable in A2A mode.

Mersenne Primes

In mathematics, a Mersenne prime is a prime number that is one less than a power of two. As of 2025, 52 Mersenne primes are known. An interesting thing about Mersenne primes is that they are the easiest natural numbers to prove to be primes, so they make up the largest category on the list of known prime numbers. This example was chosen as a good problem as the computation is CPU bound and gets exponentially longer for each higher number.

A2A Cross Language Agents

The a2a_benchmark Repo has sample scripts for running the ADK and various types of agents across programming languages. Each agent implements a Mersenne Prime Number generator with only basic optimization. The root directory of the a2a-benchmark directory contains several common agent development languages. These include:

• benchmark-go (GO) A2A Server
• benchmark-python (Python) A2A Server
• benchmark-node (JavaScript) A2A Server
• benchmark-rust (Rust) A2A Server
• benchmark-master (Python) A2A Client / MCP Server

A2A Mersenne Prime Number Agent (GO)

This agent provides a basic Agent that generates Mersenne prime numbers. To run the agent — run the bench-go.sh script:

The A2A inspector can be used to validate the Agent:

A2A Mersenne Prime Number Agent (Python)

This agent provides Python agent that implements the Mersenne generation algorithm.

This Agent can be checked with the ADK web interface:

what do you do

I can calculate Mersenne primes using the Lucas-Lehmer primality test. I can find the list of the first N Mersenne primes.

find the first 10 primes

It took 0.0002677440643310547 seconds to find the first 10 Mersenne primes.

To start the dedicated A2A version of the Python prime number generator Agent use the bench-python.sh script:

xbill@penguin:~/a2a-benchmark$ source bench-python.sh

A2A Mersenne Prime Number Agent (Node)

This agent provides a minimal agent to generate a prime number. To run the Agent use the bench-node.sh script:

The Agent can be validated with the A2A inspector on port 8103:

A typical session will look something like this:

✅

A2A Mersenne Prime Number Agent (Rust)

The Mersenne primes algorithm was newly implemented in Rust:

A sample test script verified the A2A Agent skill:

MCP Master/Orchestrator Agent (Python)

The final agent follows a slightly different pattern. It provides a minimal agent with several functions (Tools/Skills). It has one root_agent and 3 remote agents connected over A2A. This agent also exposes an interface as a MCP server- allowing Antigravity CLI to be used as a MCP client.

The Master Agent is started with a similar script:

Antigravity CLI with MCP Connection

The Master Agent starts a FastMCP server interface. This allows Antigravity CLI to be used as a MCP client:

ADK Validation of the Master Agent

Because it is Python based- the Master Agent can also be viewed with the ADK web interface:

So What is all this Doing?

All of the setup and configuration allows you to start debugging and visualizing Agent flows using the A2A protocol. The Agents can be validated using the A2A Inspector. The Python Agents can be checked with the ADK web interfaces. The Master Agent can be validated with Antigravity CLI as a MCP client.

Time to Starting Running some Numbers!

Now that the individual Agents have been validated — open several Terminal windows and start up all the remaining agents:

• benchmark-go.sh — (port 8102)
• benchmark-python.sh-(port 8101)
• benchmark-node.sh- (port 8103)
• benchmark-rust.sh- (port 8104)
• benchmark-master.sh — Orchestrator Agent (port 8100)

Start the Benchmarking Session

Once all the agents have been started — the Master agent on port 8100 is connected over MCP with Antigravity CLI:

I have completed the benchmark run across all four language agents for primes 1 to 22.

### Summary of Actions Taken:

1. Agent Startup & Verification: Automatically checked and started all four target language agents (Node. js/TypeScript, Rust, Go, Python) and verified they were active and listening on their respective A2A JSON-RPC ports.
2. Benchmark Scripting: Created a customized benchmarking script run_benchmark_1_22.py that targets prime calculations from $N = 1$ to $N = 22$.
3. Execution: Ran the benchmark and recorded the exact computation time (within the tool call) and the total Agent-to- Agent (A2A) network/orchestration latency (RTT) for every prime count $N$.
4. Data Plotting: Generated visualizations for both calculation times ( prime_calculation_times_1_22.png ) and overall latency ( a2a_latency_times_1_22.png ).
5. Reporting: Compiled all calculations and visualizations into the analysis_results.md artifact.

Review Performance

The results of the benchmark are graphed:

With latency times:

Final Results

Antigravity CLI summarized the results of the Agent Benchmarking:

### 1. Core Computation Performance (Lucas-Lehmer Prime Calculation)

### 2. A2A Framework & Protocol Overhead

and a deeper dive:

1. Rust and Node.js (Mocked Agent Logic / Direct Execution): • Both main.rs and server.ts implement custom JSON-RPC endpoints that intercept incoming queries and bypass the LLM entirely. • They use simple regex to extract the number of primes directly from the text "Calculate the first {N} Mersenne primes" , execute the math, and return a mock agent response message. Since there are no LLM API calls, the overhead is practically zero.
2. Go and Python (Real Agentic Execution via ADK): • Both Go (main.go) and Python (agent.py) use the official Agent Development Kit ( google-adk ) and hook up the Gemini 2.5 Flash model. • When they receive a message, the ADK runner executes a full agent reasoning loop. This involves two sequential remote LLM calls (one to determine which tool to call, and another to formulate the final natural language response). • This remote LLM invocation via the internet accounts for the 1.5–3.0 second latency overhead.

1. Rust (195.96 ms): • Rust is compiled to optimized native machine code (using --release ). The num-bigint crate executes the big integer arithmetic without garbage collection overhead, making it the most efficient compiled loop.
2. Node.js (214.06 ms): • V8's JIT compiler is extremely good at compiling JavaScript loops to native machine instructions. Additionally, V8's native BigInt implementation is heavily optimized at the engine level (written in assembly/C++).
3. Go (279.54 ms): • While Go compiles to native code, its implementation in main.go performs heap allocations inside the hot loop: a := new(big.Int).Rsh(s, uint(p)) b := new(big.Int).And(s, m) Allocating new big.Int objects inside a loop that runs thousands of times puts extra pressure on Go's runtime allocator and garbage collector, dragging down performance compared to Rust.
4. Python (572.48 ms): • Python handles arbitrary-precision integers natively, but executing the loop in interpreted bytecode has a lot of interpreter overhead compared to compiled or JIT-compiled languages. 9,939 iterations of the loop in bytecode is the bottleneck.

Core Findings

For low numbers of Mersenne primes that execute quickly- all four languages are comparable. An unusual result was the good performance in the mid range from Node. This could have been from lower overhead of the Node A2A toolkit or potentially from JavaScript engine optimizations. As expected, GO and Rust did break out and delivered the best performance as the complexity scaled.

Summary

The goal of the demo/article was to get basic Agents implemented across multiple programming languages and benchmark the Agent performance finding Mersenne primes.

The Google Agent development kit (ADK) was presented along with the complimentary A2A (Agent to Agent) protocol. Three basic agents were presented — covering various combinations of programming languages and Agent implementation approaches.

Finally — a Master/Orchestrator agent was started to connect and delegate to the other agents via the A2A protocol. Antigravity CLI was used to connect to the Master Agent over MCP and execute the benchmarks.### Cross Language A2A Agent Benchmarking with Gemini 3 and Antigravity CLI