Google ADK · A2A Protocol · SequentialAgent
No human intervention. Zero clicks. Pure multi-agent orchestration. Docker Compose, Jenkins, Grafana, CLI and FastAPI portal generated by specialized agents with Gemini function calling.
The analogy that explains everything
Nobody passes them variables. Nobody coordinates them manually. Each one finds and reads what the previous left written. That's A2A in the real world: asynchronous communication through shared artifacts.
That's exactly what these 7 agents do. No human intervention, zero clicks, zero editing, pure multi-agent orchestration.
Result first, explanation second. This is what you find in the output directory when the 7 agents finish.
Generated output — 21 files
test-outputs/idp-adk-sequential/
├── platform-config.yaml ← Architect
├── docker-compose/
│ └── app-stack.yml ← Infrastructure
├── security-report.json ← Security
├── cicd/ ← CI/CD
│ ├── build.sh
│ ├── test.sh
│ └── deploy.sh
├── Jenkinsfile ← CI/CD
├── grafana-dashboards/ ← Observability
│ ├── app-metrics.json
│ └── system-metrics.json
├── cli-tool/idp ← DevEx
├── portal/ ← Web Portal
│ ├── main.py
│ ├── templates/index.html
│ └── Dockerfile
└── orchestration-report.json ← Orchestrator
Docker Compose
Services with healthchecks, networks and volumes
Security Report
Vulnerabilities detected by the security agent
CI/CD Scripts
build.sh, test.sh, deploy.sh + configured Jenkinsfile
Grafana Dashboards
App metrics + System metrics, ready to import
CLI Tool
Executable with commands adapted to the generated stack
FastAPI Portal
Web dashboard with real-time Docker visualization
Platform Config
Stack decision documented with AI justification
Each agent has a single responsibility and actively reads what the previous ones left behind. None receive direct parameters — all search for the shared artifacts.
Analyzes the task and decides the full stack: runtime, framework, database, CI/CD, monitoring. Justifies each decision. Saves the configuration to a YAML file.
Reads the Architect's YAML and generates the complete Docker Compose with all services, healthchecks, networks and volumes.
Reads the Architect's decisions and the generated infrastructure. Scans with Trivy: exposed secrets, open ports, images with CVEs. Can block the pipeline if it detects critical issues. Generates a structured report.
Reads the decided stack and generates adapted automation scripts: build, test and deploy. Configures the Jenkinsfile for the complete pipeline.
Reads the infrastructure configuration and generates two Grafana dashboards: application metrics and system metrics. Configures Prometheus.
Reads the complete stack and generates an executable CLI tool with commands adapted to the project: status, logs, deploy, rollback, scale and more.
Reads the complete IDP configuration and builds a web portal with FastAPI backend, HTML templates and real-time visualization of Docker services.
Total: ~4.5 minutes · 21 files · 7/7 agents
SequentialAgent executes the 7 agents in order. But what makes the system truly work is A2A: each agent writes its decisions to a file and the next one actively reads them.
Communication flow
# Architect writes
save_platform_config("Runtime: Python...")
→ platform-config.yaml saved
# Infrastructure searches and reads
get_platform_config()
→ reads the architect's YAML
→ generates Docker Compose
# Security also searches
get_infrastructure_config()
→ reads infrastructure decisions
→ identifies vulnerabilities
Without A2A — classic pipeline
Agent 1 → return output → Agent 2
Direct coupling. If one fails,
the whole chain breaks.
With A2A — shared artifacts
Agent 1 → writes YAML
Agent 2 → actively reads YAML
Each agent is independent.
Localized debugging. Modular.
Built-in in Google ADK. Pass it the list of agents and it executes them in order. The orchestrator doesn't use an LLM — the sequence is deterministic.
from google.adk.agents import SequentialAgent
orchestrator = SequentialAgent(
name="idp_orchestrator",
sub_agents=[
platform_architect, # 1. Defines stack
infrastructure, # 2. Reads and generates Docker Compose
security, # 3. Reads and scans
cicd, # 4. Reads and generates scripts
observability, # 5. Reads and generates dashboards
devex, # 6. Reads and generates CLI
web_portal # 7. Reads everything and generates portal
]
)
Each agent has tools defined as standard Python functions. No mandatory decorators, no manual JSON schemas. ADK registers them and Gemini decides when and how to call each one.
How a tool is defined in ADK
# Regular Python function
def save_platform_config(
stack_summary: str
) -> dict:
"""
Args:
stack_summary: "Runtime: Python 3.11
| Framework: FastAPI | ..."
"""
# parses and saves config
return {"status": "success"}
# Gemini decides when to call it
# You just define it and register it
With 13+ parameters per function, Gemini failed at function calling. The success rate was 0%.
❌ 13 parameters → 0% success rate
save_config(runtime, framework, database, cloud, cicd, cache, monitoring...)
Reduce to 1 parameter with structured format in the string. The success rate became very high.
✓ 1 parameter → high reliability
save_config("Runtime: Python | Framework: FastAPI | ...")
The pattern we replicated across all 7 agents
This same pattern — 1 parameter with pipe-separated format — was applied to the tools of all agents. The result: 7/7 agents with high function calling success rate. It's a real technical finding, discovered during development.
1 tool, 1 responsibility, minimal inputs — it's exactly the Agent Skills principle applied to ADK.
The Platform Architect makes real decisions on each run. The same task can produce completely different stacks — because the model reasons, it doesn't fill a template.
Run 1
"Build IDP for Python microservices"
Run 2
"Build IDP for Python microservices"
Run 3
"Build IDP for Go microservices"
In the interactive mode shown in the video, the Platform Architect receives new instructions during the conversation and adapts its recommendations in real time: starts by recommending a local stack with Trivy, then switches to Google Cloud when asked, and finally adjusts to AWS + GitLab when that combination is specified. With each change, it explains why the previous recommendation no longer applies.
There are three scenes in the video that show real multi-agent orchestration — not simulated.
Before launching automatic mode, the screen shows that the test-outputs/ directory is completely empty.
On pressing enter, each agent starts working in sequence — and files appear in real time in the file explorer.
When done: Docker Compose, Jenkinsfile, Grafana dashboards, FastAPI portal, CLI tool. All there.
In interactive mode, the security agent receives a request. Before doing anything, it actively reads the architect's decisions and the infrastructure agent's decisions. Since infrastructure hasn't run yet, it responds:
Security Agent:
"I have tried to read the infrastructure agent's decisions,
but they were not found. The infrastructure agent
must run first."
# It wasn't hardcoded. The agent truly knows
# what state the system is in.
After the agents finish, docker-compose up -d runs with the AI-generated file.
Jenkins starts with the CI/CD job already configured. Grafana loads with the generated dashboards.
The FastAPI portal responds at localhost:8001 showing the status of all services in real time.
None of this is a simulation.
The same 7 agents, two ways to interact with them.
Chat with each agent separately from the browser. Ideal for exploring what each one does, changing preferences and seeing decisions in real time.
# One command launches everything
./start-interactive-nicolasneira.sh
# Opens localhost:8000
# Select the agent
# Chat in natural language
One command, 7 agents run in sequence, 21 files generated. Watch progress in the terminal in real time.
# One command, ~4.5 minutes
./start-demo-nicolasneira.sh \
"Build IDP for Python microservices"
# ✓ 21 files generated
# ✓ Portal at localhost:8001
Quick Start
1. git clone https://github.com/nneira/google-adk-a2a-idp
2. export GEMINI_API_KEY="your-api-key"
3. docker build -t adk-agents:hybrid .
4. ./start-demo-nicolasneira.sh "Build IDP for Python microservices"
Gemini API key available at aistudio.google.com/app/apikey
The most common questions about Google ADK, Gemini function calling and the multi-agent system.
Google ADK (Agent Development Kit) is Google's official framework for building AI agents with Gemini models. It lets you define agents as Python objects with tools, instructions and an assigned model, and orchestrate them in multi-agent systems using components like SequentialAgent. Unlike other frameworks, ADK is designed specifically for Gemini and offers function calling with no additional schema configuration. In this project it's used to coordinate 7 specialized agents that autonomously generate a complete Internal Developer Platform.
Gemini function calling is the ability of the Gemini model to decide when and how to invoke Python functions that you define. Instead of your code calling the AI and waiting for text, the model analyzes the context and executes concrete functions: save a file, query an API, read a configuration. In Google ADK you define those functions as standard Python with type hints and docstrings — the framework registers them and Gemini decides when to call them. The key technical insight from this project: more than 13 parameters per function drops the success rate to 0%. The solution is consolidating to 1 parameter with a structured format.
A2A (Agent-to-Agent) Protocol is a communication standard between AI agents, part of the Linux Foundation, that allows them to coordinate without a central orchestrator passing data directly between them. Instead of direct calls between agents, each one writes its decisions to shared artifacts — YAML files, JSON, configurations — and the next agent actively searches for and reads them when needed. In this project the Infrastructure agent doesn't receive data from the Architect as a parameter: it searches for it in the file system. This makes each agent independent and keeps debugging localized.
SequentialAgent is a built-in orchestrator agent type in Google ADK that executes a list of sub-agents in deterministic order, one after another. It doesn't use an LLM to decide the sequence — execution is fixed and predictable. You define it by passing a list of agents and ADK handles executing them in that order. In this project it coordinates the 7 specialized agents: Platform Architect first, then Infrastructure, Security, CI/CD, Observability, DevEx and Web Portal — approximately 4.5 minutes total.
Flash-Lite has inconsistent tool calling with this system — agents keep chatting instead of executing functions. Gemini 2.5 Flash has a very high success rate for this type of orchestration. The cost difference is minimal; the reliability difference is enormous.
Yes, Google ADK supports other models via LiteLLM — including Claude and GPT-4. A2A Protocol is model-agnostic by design: it's an open Linux Foundation standard, not tied to any provider. The repository as-is uses Gemini 2.5 Flash with the google-genai SDK, but you can adapt the model by changing the agent configuration to LiteLLM without rewriting the tools or orchestration logic.
They're an excellent starting point — 80% of the work is done. Before going to production you should review: hardcoded passwords, secrets management and the recommendations in the security-report.json that the system generates for you.
Yes. The SequentialAgent accepts N agents — to add one, define its Python function and add it to the sequence. To change the stack, adjust the prompt to the Platform Architect: it makes the decision based on what you ask.
The system has automatic retries: up to 3 attempts with exponential backoff before declaring a failure. If the failure is critical, the orchestrator does a rollback in reverse order and cleans up the generated files. In practice: you can restart from the agent that failed without losing the work of the previous ones.
Full repository
github.com/nneira/google-adk-a2a-idp
Full video — 49 min
youtube.com/@NicolasNeiraGarcia
Why are this IDP's agents well designed? → Agent Skills
Each agent in this system follows the Agent Skills pattern: scoped, reusable and safe. If you want to understand the conceptual architecture behind how the tools were designed, the separation of layers and why A2A works this way — that's the page.