Google ADK showcases a multi-agent pipeline for data analysis, charts, and reports in Python

Google ADK received another practical use case: a step-by-step multi-agent pipeline for data analysis in Python. The example demonstrates not just a chat with an agent, but a full-fledged working scheme that can load tables, calculate statistics, build graphs, transform data, and compile a final report.

How the Pipeline Works

The foundation of the example is a combination of google-adk, pandas, numpy, scipy, matplotlib, seaborn, and openpyxl. First, the developer sets up the environment, configures API access, and specifies the model through LiteLlm. The code uses openai/gpt-4o-mini, and this is an important detail: Google ADK acts here not as a framework exclusively for Gemini, but as an orchestration layer that can work with external models through a standard wrapper.

As a result, the tutorial looks closer to real production scenarios, where the stack is rarely built around a single vendor. Next, the guide assembles a common DataStore—a centralized repository for dataframes and analysis history. It collects loaded CSVs, generated test datasets, and results from intermediate steps. A separate helper is added for serialization so that tool responses can be safely returned in JSON.

For applied analytics, this is not mere cosmetics: without such a layer, a multi-agent system quickly runs into incompatible types, data duplication, and unclear state between steps, especially when one agent continues the work of another.

How Roles Are Distributed

Instead of a single "universal" agent, the authors break down the work into several specialized roles. This brings the pipeline closer to a real analytics team, where data loading, exploration, visualization, table transformation, and conclusion preparation rarely live in a single large script. This approach simplifies scaling: individual blocks can be changed, tested, and reused without rebuilding the entire chain, and the master agent gets more predictable executors for specific tasks.

• data_loader loads CSV and creates sample datasets: sales, customers, timeseries, and survey
• statistician calculates descriptive statistics, correlations, Shapiro-Wilk, t-test, ANOVA, and chi-square
• visualizer builds histogram, scatter, bar, line, box, heatmap, and pie charts, and creates a distribution report from four graphs
• transformer filters rows, aggregates tables, and adds computed columns
• reporter compiles a summary report with data quality, missing values, duplicates, and key findings

Above them stands the master agent data_analyst, which routes requests among specialists. The session is stored through InMemorySessionService, and execution is handled by Runner. As a result, the user can assign tasks in natural language: create a sales dataset, check the normality of distribution, build a correlation heatmap, compare revenue between customer groups, or compile a final report.

For ADK, this is a good example of how agent architecture transforms from a demo into a managed workflow with clear roles and transparent sequence of steps.

From Code to Analytics

The strong point of the example is that it covers the entire analysis journey, not just one segment. The system can start with raw data or generated datasets, quickly describe the structure of the dataset, calculate distributions and outliers, then move to graphs, and only after that to more complex comparisons and conclusions.

This order is important: in analytics, errors often start not at the model stage, but earlier, when data is still poorly understood and decisions are made based on first impressions of the table.

Additionally useful is that the tutorial is not limited to EDA. It includes steps for table transformation: filtering by condition, aggregation by groups, and computation of new fields through expressions. After that, the agent forms a summary report with a dataset overview, missing value level, number of duplicates, and basic numeric/categorical insights.

That is, ADK is used not for "pretty chat about data," but for a repeatable pipeline that can be tailored to team analytics, a BI sandbox, a training environment, or a demonstration of agent-based approach capabilities on an understandable business task.

What This Means

For Google ADK, such examples are more important than loud announcements: they demonstrate that the framework can already be applied as a foundation 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 tasks, where transparent steps, tools, and reproducible results are needed.