Google ADK Demo Shows a Multi-Agent Python Pipeline for Data Analysis, Charts and Reports

Google ADK has gained another practical use case: a step-by-step multi-agent pipeline for data analysis in Python. The example goes beyond a chat with an agent. It shows a complete working setup that can load tables, compute statistics, draw charts, transform data and assemble a final report.

How the pipeline is built

The example rests on google-adk, pandas, numpy, scipy, matplotlib, seaborn and openpyxl. The developer first sets up the environment, configures API access and defines the model through LiteLlm. The code uses openai/gpt-4o-mini, and that detail matters: Google ADK here is not a Gemini-only framework but an orchestration layer that can work with external models through a standard wrapper. This makes the tutorial look closer to real production scenarios, where the stack is rarely built around a single vendor.

The guide then builds a shared DataStore, a centralized repository for dataframes and analysis history. It holds uploaded CSVs, generated test datasets and the results of intermediate steps. A separate serialization helper lets tool responses be returned safely as JSON. For applied analytics this is not cosmetic: without such a layer, a multi-agent system quickly runs into incompatible types, duplicated data and unclear state between steps, especially when one agent picks up another's work.

Which roles split the work

Instead of one "universal" agent, the authors divide the work among several narrow roles. This brings the pipeline closer to a real analytics team, where data loading, exploration, visualization, table transformation and drafting conclusions rarely live in one big script. The approach simplifies scaling: individual blocks can be changed, tested and reused without rebuilding the whole chain, and the master agent gets more predictable executors for specific tasks.

• data_loader loads CSVs and creates sample datasets: sales, customers, timeseries and survey
• statistician computes descriptive statistics, correlations, Shapiro-Wilk, t-test, ANOVA and chi-square
• visualizer draws histogram, scatter, bar, line, box, heatmap and pie charts, and also produces a distribution report made of four plots
• transformer filters rows, aggregates tables and adds computed columns
• reporter assembles a summary report covering data quality, missing values, duplicates and key findings

Above them sits the master agent data_analyst, which routes requests between the specialists. The session is stored via InMemorySessionService, and execution runs through Runner. As a result, the user can give tasks in plain language: create a sales dataset, check whether a distribution is normal, build a correlation heatmap, compare revenue across customer groups or assemble a final report. For ADK this is a good example of agent architecture moving from demo to a managed workflow with clear roles and a transparent sequence of steps.

From code to analytics

The example's strength is that it covers the whole analysis path, not just one stage. The system can start from a raw table or generated data, quickly describe the dataset's structure, compute distributions and outliers, then move to charts and only after that to more complex comparisons and conclusions. This order matters: in analytics, errors often begin before the modeling stage, when the data is still poorly understood and decisions rest on a first impression of the table.

It is also useful that the tutorial does not stop at EDA. It includes steps for table transformation: conditional filtering, group aggregations and computing new fields through expressions. The agent then produces a summary report with a dataset overview, the share of missing values, the number of duplicates and basic numeric/categorical insights. In other words, ADK is used not for a "pretty chat about data" but for a repeatable pipeline that can be adapted for a team's internal analytics, a BI sandbox, a training stand or a demonstration of the agent approach on a clear business task.

What this means

For Google ADK, examples like this matter more than loud announcements: they show the framework can already serve as a backbone for real analytics assistants. For developers the signal is simple: the multi-agent approach is starting to work not only in research scenarios but also in everyday data analysis, where transparent steps, tools and reproducible results are needed.