Multi-Agent A2A with the Agent Development Kit(ADK), Amazon ECS Express, and Gemini CLI

DEV Community

Multi Agent Design

The multi-agent deployment consists of 5 agents:

Researcher
Judge
Orchestrator
Content Builder
Course Builder

For a detailed analysis of the multi-agent architecture- this article provides the background information:

Multi-Agent A2A with the Agent Development Kit(ADK), Cloud Run, and Gemini CLI

Running/Testing/Debugging Locally

The main Makefile has been extended with extensive targets for managing the agents on the local development environment.

The key targets include:

xbill@penguin:~/multi-agent$ make help
Available commands:
 install - Install all dependencies for root, agents, and app
 start - Start all services locally (alias for start-local)
 stop - Stop all local services (alias for stop-local)
 run - Start all services locally (alias for start-local)
 local - Show local service URLs
 start-local - Start all local services in background
 stop-local - Stop all local processes
 test - Run all tests (pytest)
 test-researcher - Test the Researcher agent directly
 test-judge - Test the Judge agent directly
 test-orchestrator - Test the Orchestrator logic
 lint - Run linting checks (ruff)
 deploy - Deploy all services to Cloud Run
 destroy - Delete all Cloud Run services
 clean - Remove caches and logs

First check for local running agents:

xbill@penguin:~/gemini-cli-aws$make status
Checking status of locally running agents and servers...
--- Network Status ---
No services listening on expected ports (8000-8004, 5173).
--- Process Status ---
No matching processes found.

Then all the agents can be started together:

✦ The frontend has been built and all local services (Researcher, Judge, Content Builder, Orchestrator, App Backend, and Frontend dev server) have
 been started in the background.
 - Frontend: http://localhost:5173 (http://localhost:5173)
 - Backend: http://localhost:8000 (http://localhost:8000)
 Logs for each service are available in the project root: researcher.log, judge.log, content_builder.log, orchestrator.log, backend.log, and
 frontend.log.

Then connect to the front end locally:

And the entire agent system will run in the local environment:

Local Logging / Debugging

Gemini CLI has full access to the local agent logs for debugging and troubleshooting:

> review the local logs for the multi-agent run
✦ I will check run_local.sh and the project structure to determine where logs are stored or how they are generated.

This will verify the local operation of the code:

✦ The local logs confirm a successful multi-agent run for the topic "the history of the internet." Here is a summary of the execution flow:
* Orchestrator (orchestrator.log): Successfully managed the pipeline. It captured the topic, coordinated the Research-Judge loop, and escalated to
 content generation after the first iteration.
 * Researcher (researcher.log): Gathered approximately 9.2KB of research data using the google_search tool. It completed its task with a 200 OK
 response.
 * Judge (judge.log): Evaluated the findings and gave a "pass" status. The judge noted that the research was "comprehensive, accurate, and
 well-structured," making it an "excellent foundation for educational content."
 * Content Builder (content_builder.log): Successfully transformed the validated research into a structured Markdown course module and finished
 execution.
 * Backend & Frontend (backend.log, frontend.log): The FastAPI backend (port 8000) and Vite frontend (port 5173) are running and communicating with
 the orchestrator as expected.
Notable Observation:
 * A minor warning appeared in researcher.log: Researcher callback: 'response' not found or has no parts. However, this did not impact the
 successful completion of the research or the overall pipeline.
All services are currently active and logged at the DEBUG level as specified in run_local.sh.

Deploying to Amazon Elastic Container Service (ECS)

The project level Makefile has targets for managing the Agent deployment to serverless endpoints. You can submit the build for ECS Express deployment:

make deploy
✦ The deployment was successful, and all 5 services are active on AWS ECS Express. You can access the Web App at the following URL:
 Web App (Course Creator): https://ad-65d6861112ff49099782001efe5e2721.ecs.us-east-1.on.aws
 The other microservices are also deployed and integrated:
 - Researcher: https://ad-8779b3dc720e4d9e9ca9b1091499084a.ecs.us-east-1.on.aws
 - Judge: https://ad-ab123be1fad04a9390e1d918f9b8ec04.ecs.us-east-1.on.aws
 - Content Builder: https://ad-622b8527fd1f41668624714f62deee0f.ecs.us-east-1.on.aws
 - Orchestrator: https://ad-c0f70b2d021744ec9761c2e54ca60287.ecs.us-east-1.on.aws

Once the containers are deployed- you can then get the endpoint:

✦ The Web App (Course Creator) endpoint is:
 https://ad-65d6861112ff49099782001efe5e2721.ecs.us-east-1.on.aws

The service will be visible in the AWS console:

And the entire system can be tested:

> make e2e-test-ecsexpress
✦ The end-to-end test of the AI Course Creator on AWS ECS Express was successful. The system, comprising 5 microservices, correctly researched
 "The History of the Internet," evaluated the findings, and generated a structured 4-module course. The public URL for the Web App is:
 https://ad-65d6861112ff49099782001efe5e2721.ecs.us-east-1.on.aws

Running the Web Interface

Start a connection to the Cloud Run deployed app:

http://a27c61bc6fb3c425ca13d862e0fe4aed-865627292.us-east-1.elb.amazonaws.com

Then connect to the app :

Then use online course generator:

Final Gemini CLI Code Review

As a final step — Gemini CLI was used for a full code review of the project:

✦ This multi-agent project is a well-engineered application of ADK 2.5 and the A2A protocol. The separation of specialized agents (Researcher,
 Judge, Content Builder) coordinated by a central Orchestrator demonstrates a mature microservice-oriented design.
Key Strengths
 * Coordinated Orchestration: The use of SequentialAgent and LoopAgent creates a robust, iterative research-judge cycle.
 * Resilient State Flow: The strategy of passing data through event content and "recovering" it via before_agent_callback heuristics is a clever
 way to handle state across distributed, independent session stores.
 * Polished Streaming: The web app's SSE implementation, specifically the greedy overlap deduplication (merge_strings) and system message
 cleanup, ensures a high-quality user experience despite the inherent noise in multi-agent LLM streams.
 * Cloud-Native Readiness: Using Identity Tokens for authenticated service-to-service communication and middleware for dynamic A2A URL rewriting
 makes the system ready for production deployment on Cloud Run.

Summary

The Agent Development Kit (ADK) was used to build a multi-agent system with A2A support using the Gemini Flash LLM Model. This application was tested locally with Gemini CLI and then deployed to AWS ECS Express. Finally, Gemini CLI was used for a complete project code review.