This tutorial aims to build and test benchmarking Agents using the A2A protocol across several mainstream Cloud providers. A Master Orchestrator Agent is exposed via MCP to allow Antigravity CLI to be used as a MCP client to co-ordinate the benchmarks.
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
In this updated version, the Antigravity CLI is used to push Rust Agents cross-cloud and co-ordinate Mersenne Prime Calculations.
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.
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 cloud comparison.
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:
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:
This article targets a local, GCP, Azure, and AWS environment. The build tools for each language and cloud environment need to be in place. For building with Rust, the Rust tool chain is required.
For GCP- this article provides some directions:
Deploying a Rust A2A Agent to Google Cloud Run
For Azure — this article provides some directions:
Deploying a Rust MCP Server to Azure ACA
For AWS — this article provides some directions:
Deploying a Rust A2A Agent to AWS Lightsail
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
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:
Verify that all the prerequisite packages and compilers are installed — and clone the sample Github repo:
git clone https://github.com/xbill9/a2a-multicloud
cd a2a-multicloud
Once you have your Google Cloud Project and preferred authentication method — run the init.sh script to validate the setup:
xbill@penguin:~/a2a-multicloud$ source init.sh
WARNING: Your active project does not match the quota project in your local Application Default Credentials file. This might result in unexpected quota issues.
To update your Application Default Credentials quota project, use the `gcloud auth application-default set-quota-project` command.
[environment: Development]
Updated property [core/project].
ADC is valid.
Environment setup
GOOGLE_GENAI_USE_VERTEXAI=1
GOOGLE_CLOUD_PROJECT=comglitn
GOOGLE_CLOUD_LOCATION=us-central1
IMAGEN_MODEL="imagen-3.0-fast-generate-001"
GENAI_MODEL="gemini-2.5-flash"
Cloud Login
Credentialed Accounts
ACTIVE ACCOUNT
* xbill@glitnir.com
To set the active account, run:
$ gcloud config set account `ACCOUNT`
The set_env.sh script is provided to set common ADK environment variables:
xbill@penguin:~/a2a-multicloud$ source set_env.sh
Current Environment
export GOOGLE_GENAI_USE_VERTEXAI=1
export GOOGLE_CLOUD_PROJECT=comglitn
export GOOGLE_CLOUD_LOCATION=us-central1
export IMAGEN_MODEL="imagen-3.0-fast-generate-001"
export GENAI_MODEL="gemini-2.5-flash"
export GCP_AGENT_URL="https://bench-rust-289270257791.us-central1.run.app"
export AWS_AGENT_URL="https://a2a-lightsail-rust-aws.6wpv8vensby5c.us-east-1.cs.amazonlightsail.com"
export AZURE_AGENT_URL="https://a2a-app-penguin.icyplant-a768d75c.westus2.azurecontainerapps.io"
Cloud Login
Credentialed Accounts
ACTIVE ACCOUNT
* xbill@glitnir.com
To set the active account, run:
$ gcloud config set account `ACCOUNT`
ADK Version
adk, version 2.1.0
If your application default credentials expires or your Google Cloud Authentication expires you will get an error. The workaround is to re-authenticate:
gcloud auth login
gcloud auth application-default login
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:
cd ~/a2a-multicloud
source set_env.sh
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
A summary of the features of the A2A inspector can be found here:
To install the A2A Inspector:
cd ~
git clone https://github.com/a2aproject/a2a-inspector
Then follow the build instructions — you need ** uv** , and a recent version of
a2a-inspector/README.md at main · a2aproject/a2a-inspector
Once the A2A inspector has been installed- you can validate the installation by using this URL:
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.
The a2a-multicloud Repo has sample scripts for running the agents across cloud environments. Each agent implements a Mersenne Prime Number generator with only basic optimization. The root directory of the a2a-multicloud directory contains several common agent development languages. These include:
This agent provides a basic Agent that generates Mersenne prime numbers.
The A2A inspector can be used to validate the Agent:
The agent can be reviewed:
xbill@penguin:~/a2a-multicloud/benchmark-rust$ make start
Building the Rust project...
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.05s
Starting local agent on port 8104 in the background...
Local agent started successfully (PID: 87753).
xbill@penguin:~/a2a-multicloud/benchmark-rust$ make status
Local agent is running (PID: 87753).
Listening on port: 8104
Testing endpoint health...
OK
and the agent card:
xbill@penguin:~/a2a-multicloud/benchmark-rust$ make card
Fetching local benchmark agent card from http://localhost:8104...
{
"name": "Mersenne Prime Agent Rust",
"description": "A rust agent that builds a list of the first n Mersenne primes and reports the elapsed time. Configured with model: Not specified.",
"protocolVersion": "0.3.0",
"version": "0.1.0",
"url": "http://0.0.0.0:8104",
"skills": [
{
"id": "find-mersenne-rust",
"name": "Find Mersenne Primes in rust",
"description": "Finds the list of the first n Mersenne primes in Rust, or calculates a specific Mersenne prime for a given exponent parameter.",
"tags": [
"math",
"benchmark"
]
},
{
"id": "check-status-rust",
"name": "Check calculation status in Rust",
"description": "Returns 'ready' if no calculation is active, and 'not ready' if a calculation is live.",
"tags": [
"status",
"health"
]
}
],
"capabilities": {},
"defaultInputModes": [],
"defaultOutputModes": []
}
and local A2A call:
xbill@penguin:~/a2a-multicloud/benchmark-rust$ make a2a
Sending A2A status request to http://localhost:8104/...
{
"id": 1,
"jsonrpc": "2.0",
"result": {
"contextId": "status-context-id",
"kind": "message",
"messageId": "971ff86d-7bfc-4046-858a-16e7857ba9d0",
"parts": [
{
"kind": "text",
"text": "ready"
}
],
"role": "agent"
}
}
This agent provides Rust agent that implements the Mersenne generation algorithm Hosted on GCP.
xbill@penguin:~/a2a-multicloud/benchmark-rust-gcp
make deploy
xbill@penguin:~/a2a-multicloud/benchmark-rust-gcp$ make endpoint
https://bench-rust-fgasxpwzoq-uc.a.run.app
Then get the Agent Card:
xbill@penguin:~/a2a-multicloud/benchmark-rust-gcp$ make status
Checking Google Cloud Run service status for bench-rust...
NAME STATUS URL
bench-rust True https://bench-rust-fgasxpwzoq-uc.a.run.app
Checking deployed agent health at https://bench-rust-fgasxpwzoq-uc.a.run.app/.well-known/agent.json ...
Agent health check: PASSED (HTTP 200)
To check the Agent Card:
xbill@penguin:~/a2a-multicloud/benchmark-rust-gcp$ make card
Fetching agent card from https://bench-rust-fgasxpwzoq-uc.a.run.app/.well-known/agent-card.json ...
{
"name": "Mersenne Prime Agent Rust",
"description": "A rust agent that builds a list of the first n Mersenne primes and reports the elapsed time. Configured with model: Not specified.",
"protocolVersion": "0.3.0",
"version": "0.1.0",
"url": "http://0.0.0.0:8080",
"skills": [
{
"id": "find-mersenne-rust",
"name": "Find Mersenne Primes in rust",
"description": "Finds the list of the first n Mersenne primes in Rust, or calculates a specific Mersenne prime for a given exponent parameter.",
"tags": [
"math",
"benchmark"
]
},
{
"id": "check-status-rust",
"name": "Check calculation status in Rust",
"description": "Returns 'ready' if no calculation is active, and 'not ready' if a calculation is live.",
"tags": [
"status",
"health"
]
}
],
"capabilities": {},
"defaultInputModes": [],
"defaultOutputModes": []
}
To check that that remote agent can support A2A:
xbill@penguin:~/a2a-multicloud/benchmark-rust-gcp$ make a2a
Sending A2A status request to https://bench-rust-fgasxpwzoq-uc.a.run.app/ ...
{
"id": 1,
"jsonrpc": "2.0",
"result": {
"contextId": "status-context-id",
"kind": "message",
"messageId": "108d0f7c-c2e6-4d1e-8306-843a6dcb999c",
"parts": [
{
"kind": "text",
"text": "ready"
}
],
"role": "agent"
}
}
This agent provides Rust agent that implements the Mersenne generation algorithm Hosted on Azure:
xbill@penguin:~/a2a-multicloud/benchmark-rust-azure$ make deploy
All requirements met.
Building the Docker image...
xbill@penguin:~/a2a-multicloud/benchmark-rust-azure$ make endpoint
https://a2a-app-penguin.icyplant-a768d75c.westus2.azurecontainerapps.io
Then get the Agent Card:
xbill@penguin:~/a2a-multicloud/benchmark-rust-azure$ make status
mcp-aca-rust-azure is not running locally.
Checking Azure Container App status for a2a-app-penguin...
Name ProvisioningState FQDN
--------------- ------------------- ---------------------------------------------------------------
a2a-app-penguin Succeeded a2a-app-penguin.icyplant-a768d75c.westus2.azurecontainerapps.io
Checking deployed agent health at https://a2a-app-penguin.icyplant-a768d75c.westus2.azurecontainerapps.io/.well-known/agent.json ...
Agent health check: PASSED (HTTP 200)
To check the Agent Card:
xbill@penguin:~/a2a-multicloud/benchmark-rust-azure$ make card
Fetching agent card from https://a2a-app-penguin.icyplant-a768d75c.westus2.azurecontainerapps.io/.well-known/agent-card.json ...
{
"name": "Mersenne Prime Agent Rust",
"description": "A rust agent that builds a list of the first n Mersenne primes and reports the elapsed time. Configured with model: Not specified.",
"protocolVersion": "0.3.0",
"version": "0.1.0",
"url": "http://0.0.0.0:8080",
"skills": [
{
"id": "find-mersenne-rust",
"name": "Find Mersenne Primes in rust",
"description": "Finds the list of the first n Mersenne primes in Rust, or calculates a specific Mersenne prime for a given exponent parameter.",
"tags": [
"math",
"benchmark"
]
},
{
"id": "check-status-rust",
"name": "Check calculation status in Rust",
"description": "Returns 'ready' if no calculation is active, and 'not ready' if a calculation is live.",
"tags": [
"status",
"health"
]
}
],
"capabilities": {},
"defaultInputModes": [],
"defaultOutputModes": []
}
To check that that remote agent can support A2A:
xbill@penguin:~/a2a-multicloud/benchmark-rust-azure$ make a2a
Sending A2A status request to https://a2a-app-penguin.icyplant-a768d75c.westus2.azurecontainerapps.io/...
{
"id": 1,
"jsonrpc": "2.0",
"result": {
"contextId": "status-context-id",
"kind": "message",
"messageId": "5d6605f6-9926-481f-b807-8598b81b8cc1",
"parts": [
{
"kind": "text",
"text": "ready"
}
],
"role": "agent"
}
}
This agent provides Rust agent that implements the Mersenne generation algorithm Hosted on AWS:
xbill@penguin:~/a2a-multicloud/benchmark-rust-aws$ make deploy
Building the Docker image...
[+] Building 3.8s (10/13)
xbill@penguin:~/a2a-multicloud/benchmark-rust-aws$ make endpoint
https://a2a-lightsail-rust-aws.6wpv8vensby5c.us-east-1.cs.amazonlightsail.com/
Then get the Agent Card:
xbill@penguin:~/a2a-multicloud/benchmark-rust-aws$ make status
Checking AWS Lightsail service status for a2a-lightsail-rust-aws...
------------------------------------------------------------------------------------------------------------------------
| GetContainerServices |
+------------+--------+------------+-----------------------------------------------------------------------------------+
| Deployment | Power | State | URL |
+------------+--------+------------+-----------------------------------------------------------------------------------+
| ACTIVE | nano | DEPLOYING | https://a2a-lightsail-rust-aws.6wpv8vensby5c.us-east-1.cs.amazonlightsail.com/ |
+------------+--------+------------+-----------------------------------------------------------------------------------+
Checking endpoint health at https://a2a-lightsail-rust-aws.6wpv8vensby5c.us-east-1.cs.amazonlightsail.com/health...
Health status: HEALTHY (HTTP 200)
To check the Agent Card:
xbill@penguin:~/a2a-multicloud/benchmark-rust-aws$ make card
Fetching agent card from https://a2a-lightsail-rust-aws.6wpv8vensby5c.us-east-1.cs.amazonlightsail.com/.well-known/agent-card.json ...
{
"name": "Mersenne Prime Agent Rust",
"description": "A rust agent that builds a list of the first n Mersenne primes and reports the elapsed time. Configured with model: Not specified.",
"protocolVersion": "0.3.0",
"version": "0.1.0",
"url": "http://0.0.0.0:8080",
"skills": [
{
"id": "find-mersenne-rust",
"name": "Find Mersenne Primes in rust",
"description": "Finds the list of the first n Mersenne primes in Rust, or calculates a specific Mersenne prime for a given exponent parameter.",
"tags": [
"math",
"benchmark"
]
},
{
"id": "check-status-rust",
"name": "Check calculation status in Rust",
"description": "Returns 'ready' if no calculation is active, and 'not ready' if a calculation is live.",
"tags": [
"status",
"health"
]
}
],
"capabilities": {},
"defaultInputModes": [],
"defaultOutputModes": []
}
To check that that remote agent can support A2A:
xbill@penguin:~/a2a-multicloud/benchmark-rust-aws$ make a2a
Sending A2A status request to https://a2a-lightsail-rust-aws.6wpv8vensby5c.us-east-1.cs.amazonlightsail.com/...
{
"id": 1,
"jsonrpc": "2.0",
"result": {
"contextId": "status-context-id",
"kind": "message",
"messageId": "1245ea8c-e8d3-436a-8e27-0b25e90a8a42",
"parts": [
{
"kind": "text",
"text": "ready"
}
],
"role": "agent"
}
}
The final agent follows a slightly different pattern. It provides a minimal agent with several functions (Tools/Skills).
To build-
make
xbill@penguin:~/a2a-multicloud/rust-master$ make lint
Linting the Rust project...
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.09s
To get the local endpoint:
xbill@penguin:~/a2a-multicloud/rust-master$ make endpoint
http://localhost:8100
Then use the A2A inspector:
and check the A2A Agent card:
xbill@penguin:~/a2a-multicloud/rust-master$ make card
Fetching master agent card from http://localhost:8100...
{
"name": "master_agent",
"description": "Master A2A Agent that coordinates prime agents (including rust_agent, gcp_agent, aws_agent, and azure_agent) using model: gemini-2.5-flash.",
"protocolVersion": "0.3.0",
"version": "0.1.0",
"url": "http://0.0.0.0:8100/",
"skills": [
{
"id": "coordinate-agents",
"name": "Coordinate sub-agents",
"description": "Delegates requests to appropriate sub-agents for weather, time, events, prime calculations, and general greetings.",
"tags": [
"coordinator",
"a2a"
]
},
{
"id": "calculate-mersenne-prime",
"name": "Calculate Mersenne Prime",
"description": "Calculates Mersenne prime of n using connected sub-agents.",
"tags": [
"mersenne",
"prime",
"a2a"
]
}
],
"capabilities": {},
"defaultInputModes": [],
"defaultOutputModes": []
}
and A2A status:
xbill@penguin:~/a2a-multicloud/rust-master$ make a2a
Sending A2A status request to http://localhost:8100/...
The Master Agent starts a FastMCP server interface. This allows Antigravity CLI to be used as a MCP client:
xbill@penguin:~/a2a-multicloud/.agents$ more mcp_config
{
"mcpServers": {
"rust-master": {
"command": "cargo",
"args": ["run", "--manifest-path", "/home/xbill/a2a-multicloud/rust-master/Cargo.toml", "--quiet", "--", "--stdio"],
"env": {
"GOOGLE_GENAI_USE_VERTEXAI": "1",
"GOOGLE_CLOUD_PROJECT": "aisprint-491218",
"GOOGLE_CLOUD_LOCATION": "us-central1",
"GENAI_MODEL": "gemini-2.5-flash",
"MODEL_NAME": "gemini-2.5-flash"
}
}
}
}
The MCP tools can be reviewed:
MCP Servers
Plugins (~/.gemini/antigravity-cli/plugins)
✓ google-dev-knowledge Tools: search_documents, answer_query, get_documents
✓ rust-master Tools: ask_master_agent, calculate_mersenne_prime, check_agents_status
The agent status can be checked with a MCP call to the Master Agent:
● rust-master/check_agents_status(Call check_agents_status MCP tool) (ctrl+o to expand)
I ran the check_agents_status tool from the rust-master MCP server. The check succeeded, confirming that all sub-
agents are healthy and online:
• AWS (Remote): ✅ ONLINE (HTTP 200)
• GCP (Remote): ✅ ONLINE (HTTP 200)
• Azure (Remote): ✅ ONLINE (HTTP 200)
• Rust (Local): ✅ ONLINE (HTTP 200)
### Summary of Work:
1. Inspected Makefile & Scripts: Reviewed target definitions ( make status , make a2a ) and script configurations.
2. Checked Endpoint Health: Verified the agent URL parameters and credentials from .env .
3. Executed MCP Status Tool: Invoked the lazy-loaded MCP tool check_agents_status from the rust-master
coordinator, confirming all remote and local calculation sub-agents are online and ready to accept tasks.
and the agent can be verified:
> ask_master_agent what do you do
● rust-master/ask_master_agent(Call ask_master_agent MCP tool) (ctrl+o to expand)
I called the ask_master_agent tool with the query "what do you do".
Here is the response from the Master Agent:
│ "I am a Master A2A Agent. I can delegate tasks to specialized sub-agents (Rust, GCP, AWS, or Azure agents) to
│ calculate Mersenne primes or check exponents."
### Summary of Work:
1. Invoked the MCP Tool: Called ask_master_agent on the rust-master server with the prompt what do you do .
2. Presented the Results: Relayed the master agent's self-description as a coordinator for distributed multi-cloud
Mersenne prime calculations.
All of the setup and configuration allows you to start debugging and visualizing Agent flows using the A2A protocol. The remote Agents haven been validated using the A2A Inspector. The Master Agent acts as a co-ordinator to delegate Mersenne Prime Calculations to remote A2A agents cross cloud.
Now that the individual Agents have been validated — open antigravity and use the MCP tool to start the session:
> what does calculate_mersenne_prime do?
● Search(Grep search run_a2a_benchmark) (ctrl+o to expand)
I will view the definition of run_a2a_benchmark (which implements calculate_mersenne_prime ) in rust-
master/src/main.rs .
● Read(/home/xbill/a2a-multicloud/rust-master/src/main.rs) (ctrl+o to expand)
The calculate_mersenne_prime(n) tool executes a distributed benchmark to find and verify Mersenne primes (2ᵖ - 1)
for exponents from 1 to n.
### How it Works:
1. Assigns Tasks Round-Robin: It iterates through the exponents 1 ≤ i ≤ n and checks the readiness of the connected
sub-agents (GCP, AWS, Azure, and Local) using a round-robin schedule.
2. Delegates Computation: Once a ready agent is found, the master agent sends the exponent i to it via the A2A
protocol. The sub-agent calculates whether 2ⁱ - 1 is prime.
3. Aggregates Timings & Results: It measures the ready check time and the calculation time for each exponent.
4. Saves Metrics: The benchmark results, including timing data and calculated primes, are compiled into a summary
markdown table and persisted to disk (e.g., in benchmark_results.json).
### Summary of Work:
1. Source Code Review: Inspected the main.rs function in rust-master/src/main.rs to extract the exact
program flow and role of each agent.
2. Explained Mechanics: Highlighted the round-robin task assignment, remote A2A calls, and metrics compilation
features.
Once all the agents have been started — the Master agent on port 8100 is connected over MCP with Antigravity CLI:
> run the calculate_mersenne_prime with 100
I will execute the calculation of Mersenne primes up to exponent 100 by querying the Master Agent's HTTP MCP route.
● Bash(curl -s -X POST -H "Content-Type: application/json" -d '{"jsonrpc": "2.0", "id": 1, "method": ...) (ctrl+o to
expand)
I will wait for the distributed calculation up to exponent 100 to complete.
The distributed calculation up to exponent n = 100 has completed successfully!
### Distributed Mersenne Prime Generation Report
• Timestamp: 2026-06-02T13:40:04-04:00
• Cumulative Duration: 55,625.57 ms (~55.6 seconds)
#### Generated Mersenne Primes
• 2² - 1 = 3 (via AWS Lightsail)
• 2³ - 1 = 7 (via Azure Container Apps)
• 2⁵ - 1 = 31 (via GCP Cloud Run)
• 2⁷ - 1 = 127 (via Azure Container Apps)
• 2¹³ - 1 = 8,191 (via GCP Cloud Run)
• 2¹⁷ - 1 = 131,071 (via GCP Cloud Run)
• 2¹⁹ - 1 = 524,287 (via Azure Container Apps)
• 2³¹ - 1 = 2,147,483,647 (via Azure Container Apps)
• 2⁶¹ - 1 = 2,305,843,009,213,693,951 (via GCP Cloud Run)
• 2⁸⁹ - 1 = 618,970,019,642,690,137,449,562,111 (via GCP Cloud Run)
──────
### Coordinated Exponent Assignments
Exponent | Assigned Agent | Ready Check Time | Calc Time | Result
--------------------|------------------------|----------------------|----------------------|----------------------
1 | GCP (Cloud Run) | 662.32 ms | 658.00 ms | not prime
2 | AWS (Lightsail) | 418.86 ms | 117.14 ms | 3
3 | Azure (Container Apps) | 330.12 ms | 366.37 ms | 7
4 | Rust (Local) | 30.34 ms | 12.07 ms | not prime
5 | GCP (Cloud Run) | 651.16 ms | 667.50 ms | 31
6 | AWS (Lightsail) | 119.91 ms | 103.80 ms | not prime
7 | Azure (Container Apps) | 337.03 ms | 338.40 ms | 127
8 | Rust (Local) | 30.31 ms | 13.20 ms | not prime
9 | GCP (Cloud Run) | 628.36 ms | 621.74 ms | not prime
10 | AWS (Lightsail) | 108.49 ms | 113.11 ms | not prime
11 | Azure (Container Apps) | 336.13 ms | 324.22 ms | not prime
12 | Rust (Local) | 21.45 ms | 15.00 ms | not prime
13 | GCP (Cloud Run) | 629.91 ms | 662.56 ms | 8191
14 | AWS (Lightsail) | 111.40 ms | 119.59 ms | not prime
15 | Azure (Container Apps) | 325.95 ms | 336.56 ms | not prime
16 | Rust (Local) | 36.22 ms | 13.74 ms | not prime
17 | GCP (Cloud Run) | 678.16 ms | 635.27 ms | 131071
18 | AWS (Lightsail) | 111.02 ms | 115.05 ms | not prime
19 | Azure (Container Apps) | 343.99 ms | 306.91 ms | 524287
20 | Rust (Local) | 24.83 ms | 25.15 ms | not prime
21 | GCP (Cloud Run) | 612.20 ms | 610.21 ms | not prime
22 | AWS (Lightsail) | 103.64 ms | 121.31 ms | not prime
23 | Azure (Container Apps) | 362.88 ms | 361.34 ms | not prime
24 | Rust (Local) | 25.12 ms | 14.09 ms | not prime
25 | GCP (Cloud Run) | 646.72 ms | 641.75 ms | not prime
26 | AWS (Lightsail) | 98.67 ms | 109.74 ms | not prime
27 | Azure (Container Apps) | 380.92 ms | 319.36 ms | not prime
28 | Rust (Local) | 24.17 ms | 17.71 ms | not prime
29 | GCP (Cloud Run) | 596.21 ms | 615.23 ms | not prime
30 | AWS (Lightsail) | 110.32 ms | 102.89 ms | not prime
31 | Azure (Container Apps) | 393.16 ms | 325.54 ms | 2147483647
32 | Rust (Local) | 20.81 ms | 14.46 ms | not prime
33 | GCP (Cloud Run) | 616.02 ms | 610.53 ms | not prime
34 | AWS (Lightsail) | 98.09 ms | 113.49 ms | not prime
35 | Azure (Container Apps) | 331.80 ms | 396.37 ms | not prime
36 | Rust (Local) | 27.76 ms | 26.81 ms | not prime
37 | GCP (Cloud Run) | 626.58 ms | 641.85 ms | not prime
38 | AWS (Lightsail) | 108.36 ms | 110.98 ms | not prime
39 | Azure (Container Apps) | 343.18 ms | 341.17 ms | not prime
40 | Rust (Local) | 30.80 ms | 21.23 ms | not prime
41 | GCP (Cloud Run) | 606.28 ms | 637.02 ms | not prime
42 | AWS (Lightsail) | 106.25 ms | 116.14 ms | not prime
43 | Azure (Container Apps) | 339.94 ms | 318.64 ms | not prime
44 | Rust (Local) | 21.90 ms | 12.41 ms | not prime
45 | GCP (Cloud Run) | 628.11 ms | 640.00 ms | not prime
46 | AWS (Lightsail) | 100.35 ms | 112.84 ms | not prime
47 | Azure (Container Apps) | 343.33 ms | 323.55 ms | not prime
48 | Rust (Local) | 19.90 ms | 28.04 ms | not prime
49 | GCP (Cloud Run) | 643.14 ms | 664.11 ms | not prime
50 | AWS (Lightsail) | 113.88 ms | 103.43 ms | not prime
51 | Azure (Container Apps) | 364.66 ms | 317.36 ms | not prime
52 | Rust (Local) | 22.84 ms | 14.70 ms | not prime
53 | GCP (Cloud Run) | 617.28 ms | 651.10 ms | not prime
54 | AWS (Lightsail) | 103.60 ms | 114.45 ms | not prime
55 | Azure (Container Apps) | 340.59 ms | 323.87 ms | not prime
56 | Rust (Local) | 26.55 ms | 11.62 ms | not prime
57 | GCP (Cloud Run) | 635.30 ms | 625.28 ms | not prime
58 | AWS (Lightsail) | 106.18 ms | 117.21 ms | not prime
59 | Azure (Container Apps) | 328.18 ms | 336.98 ms | not prime
60 | Rust (Local) | 16.18 ms | 17.11 ms | not prime
61 | GCP (Cloud Run) | 621.01 ms | 642.30 ms | 2305843009213693951
62 | AWS (Lightsail) | 106.05 ms | 115.97 ms | not prime
63 | Azure (Container Apps) | 322.90 ms | 346.61 ms | not prime
64 | Rust (Local) | 25.02 ms | 13.26 ms | not prime
65 | GCP (Cloud Run) | 610.11 ms | 627.14 ms | not prime
66 | AWS (Lightsail) | 105.60 ms | 107.45 ms | not prime
67 | Azure (Container Apps) | 337.70 ms | 323.28 ms | not prime
68 | Rust (Local) | 15.38 ms | 20.14 ms | not prime
69 | GCP (Cloud Run) | 625.35 ms | 643.10 ms | not prime
70 | AWS (Lightsail) | 108.00 ms | 108.02 ms | not prime
71 | Azure (Container Apps) | 323.01 ms | 331.95 ms | not prime
72 | Rust (Local) | 31.18 ms | 28.03 ms | not prime
73 | GCP (Cloud Run) | 647.98 ms | 627.10 ms | not prime
74 | AWS (Lightsail) | 107.88 ms | 112.41 ms | not prime
75 | Azure (Container Apps) | 351.71 ms | 340.42 ms | not prime
76 | Rust (Local) | 21.00 ms | 25.80 ms | not prime
77 | GCP (Cloud Run) | 624.00 ms | 647.06 ms | not prime
78 | AWS (Lightsail) | 97.09 ms | 111.97 ms | not prime
79 | Azure (Container Apps) | 337.90 ms | 346.54 ms | not prime
80 | Rust (Local) | 24.42 ms | 13.95 ms | not prime
81 | GCP (Cloud Run) | 624.80 ms | 631.11 ms | not prime
82 | AWS (Lightsail) | 108.87 ms | 107.81 ms | not prime
83 | Azure (Container Apps) | 332.57 ms | 322.07 ms | not prime
84 | Rust (Local) | 19.99 ms | 16.02 ms | not prime
85 | GCP (Cloud Run) | 622.47 ms | 651.63 ms | not prime
86 | AWS (Lightsail) | 112.12 ms | 107.24 ms | not prime
87 | Azure (Container Apps) | 332.57 ms | 340.05 ms | not prime
88 | Rust (Local) | 24.79 ms | 29.77 ms | not prime
89 | GCP (Cloud Run) | 646.21 ms | 667.60 ms | 618970019642690137449562111
90 | AWS (Lightsail) | 102.15 ms | 113.82 ms | not prime
91 | Azure (Container Apps) | 343.99 ms | 342.82 ms | not prime
92 | Rust (Local) | 29.97 ms | 13.91 ms | not prime
93 | GCP (Cloud Run) | 661.59 ms | 662.92 ms | not prime
94 | AWS (Lightsail) | 112.50 ms | 112.80 ms | not prime
95 | Azure (Container Apps) | 328.13 ms | 337.41 ms | not prime
96 | Rust (Local) | 26.83 ms | 24.57 ms | not prime
97 | GCP (Cloud Run) | 636.67 ms | 601.39 ms | not prime
98 | AWS (Lightsail) | 105.62 ms | 112.77 ms | not prime
99 | Azure (Container Apps) | 327.66 ms | 327.75 ms | not prime
100 | Rust (Local) | 31.73 ms | 18.09 ms | not prime
──────
### Summary of Work:
1. Invoked Calculation via HTTP Endpoint: Executed the calculate_mersenne_prime call with n = 100 against the
Master Agent's HTTP POST interface.
2. Aggregated Results: Processed the response containing two additional large Mersenne primes (2⁶¹ - 1 and 2⁸⁹ - 1)
and the complete assignment distribution.
The results of the benchmark are graphed:
Antigravity CLI summarized the results of the Agent Benchmarking:
> summarize key results cross cloud
▸ Thought Process
Analyzing Cross-Cloud Results
Here is a cross-cloud summary of the key findings, focusing on architecture, network latency, authentication overhead,
and calculation behaviors:
### 1. Latency & Network Transit Comparison
The total round-trip time (RTT) for a single round of checks and calculation varies heavily by cloud service model:
• AWS (Lightsail): ~232 ms RTT (120ms Ready Check + 112ms Calculation)
• Strengths: Lightsail container instances behave very similarly to standard VMs, offering quick, persistent HTTP
response times and low network hops.
• Azure (Container Apps): ~679 ms RTT (341ms Ready Check + 338ms Calculation)
• Characteristics: Azure Container Apps run inside a managed Kubernetes framework (K8s/Envoy ingress), adding
slight container routing and warm-up latency.
• GCP (Cloud Run): ~1,275 ms RTT (635ms Ready Check + 640ms Calculation)
• Characteristics: Serverless scaling latency, combined with authentication checks, leads to the highest round-
trip time.
──────
### 2. The Authentication Overhead (The "Why")
There is a massive latency difference between GCP and the other clouds, caused by security configurations:
• GCP Cloud Run: Requires secure OIDC identity authentication. For every single network call, the master agent calls
gcloud auth print-identity-token as a local subprocess. Spawning this CLI subprocess on every check and call
introduces an extra ~300ms to ~500ms of local delay.
• AWS & Azure: These sub-agents are deployed with publicly accessible HTTP endpoints that do not require OIDC tokens,
avoiding any local CLI token generation overhead.
──────
### 3. Latency Symmetry (Network vs. Compute)
Across all cloud providers, the Ready Check Time and Calculation Time are nearly identical:
• AWS: ~120 ms vs ~112 ms
• Azure: ~341 ms vs ~338 ms
• GCP: ~635 ms vs ~640 ms
Insight: This symmetry proves that network transport and handshake/auth overhead (ping and TLS/IAM checks) constitute
over 95% of the latency. The actual math workload (calculating exponent primality) is extremely fast and has
negligible latency impact at these exponent sizes.
──────
### 4. Cross-Cloud Protocol Success
• The master agent successfully coordinated with all three major cloud providers (GCP, AWS, Azure) and the local
runner.
• Multi-cloud work distribution successfully validated Mersenne prime candidates, returning identical results
regardless of which cloud hosting provider did the execution.
### Summary of Work:
1. Analyzed Authentication Mechanics: Explored the main.rs subprocess overhead in the coordinator codebase.
2. Evaluated Latency Patterns: Compared ready checks vs. calculation times to deduce that network transit and
security handshakes dominate overall duration.
To improve the GCP numbers- the Auth token is preset:
export GCP_ID_TOKEN=$(gcloud auth print-identity-token)
Then the benchmark is re-run. There is a slight variance on each run:
Here is a summary of the performance and distribution metrics comparing the cloud providers and the local environment
from the Mersenne prime calculation run (exponents 1 to 100):
### Overall Performance Metrics
Environment | Tasks Ass… | Cold Start Ready… | Avg Warm Ready T… | Avg Calculation T… | Compute Perform…
------------------------|------------|-------------------|-------------------|--------------------|------------------
Rust (Local) | 25 | 12.23 ms | 21.63 ms | 11.37 ms | #1 (Fastest)
AWS (Lightsail) | 25 | 544.26 ms | 107.94 ms | 110.79 ms | #2
GCP (Cloud Run) | 25 | 484.59 ms | 127.31 ms | 135.49 ms | #3
Azure (Container Apps) | 25 | 20,711.57 ms | 348.39 ms | 354.26 ms | #4 (Slowest)
──────
### Key Findings
1. Cold Starts & Overhead (Ready Time):
• Azure (Container Apps) experienced a significant initial cold start latency of ~20.7 seconds on its very first
assignment (exponent 3). Even once warm, its ready time overhead (~348 ms) remained roughly 3x slower than AWS
and GCP.
• AWS (Lightsail) and GCP (Cloud Run) showed excellent and comparable warm ready times of 108 ms and 127 ms
respectively, with minor startup penalties (~500 ms) on their first task execution.
2. Compute Performance (Calculation Time):
• Local Rust is the fastest (~11.4 ms average) because it runs bare metal without any network traversal, agent
orchestration, or cloud virtualization overhead.
• AWS outperformed both GCP and Azure, running calculations in 110.79 ms average.
• GCP followed closely behind AWS at 135.49 ms average.
• Azure was the slowest cloud computing node, taking 354.26 ms average—roughly 3x slower than AWS and 2.6x slower
than GCP.
3. Mersenne Primes Discovered by Agent:
• GCP (Cloud Run): Discovered 5 primes (Exponents: 5, 13, 17, 61, 89)
• Azure (Container Apps): Discovered 4 primes (Exponents: 3, 7, 19, 31)
• AWS (Lightsail): Discovered 1 prime (Exponent: 2)
• Rust (Local): Discovered 0 primes (Since tasks were assigned in a round-robin format, the local agent was
assigned exponents that are multiples of 4 (4,8,12,…), none of which are prime).
After adjusting the OIDC token for GCP- the benchmark was re-run:
The goal of the demo/article was to get basic Agents implemented across multiple clouds and benchmark the Agent performance finding Mersenne primes.
The key to the solution was the A2A (Agent to Agent) protocol. One local and three remote agents were presented — covering various combinations of deployment clouds.
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.