Google AI Agents Live + Labs Benelux 2025: Hands-On with ADK and Winning the Hackathon Experience

The rapid evolution of AI agents is reshaping how modern software systems are designed, operated, and scaled. Instead of treating large language models as isolated conversational assistants, the industry is moving toward agent-based systems that combine reasoning, structured context, and controlled actions to solve real operational problems.

This shift was clearly reflected at Google AI Agents Live + Labs Benelux 2025, a builder-focused event that brought together engineers and architects to work directly with Google’s emerging AI agent ecosystem. The emphasis throughout the event was not on experimentation or prompt engineering, but on production-grade agent design.

Google AI Agents Live + Labs Benelux 2025

The event was structured around a simple but important idea: AI agents should be treated as system components, not novelty features. Sessions and labs focused on how agents integrate with real infrastructure, data platforms, and operational workflows, where correctness, safety, and observability are non-negotiable.

A central theme was the Agent Development Kit (ADK), Google’s framework for building agents that operate within explicit boundaries. Rather than encouraging unrestricted autonomy, ADK promotes disciplined agent behavior through clear definitions of context, tools, and execution flows.

This framing resonated strongly with participants who are already dealing with complex production systems and cannot afford unpredictable behavior.

Hands-On Experience with ADK

The hands-on labs provided direct exposure to ADK’s design philosophy. Participants worked through exercises that emphasized:

Clear definition of agent responsibilities
Explicit registration of tools and actions
Separation between reasoning and execution
Structured inputs and outputs

Instead of embedding logic inside prompts, ADK encourages developers to externalize system state and actions, allowing the agent to focus on reasoning. This approach makes agent behavior easier to understand, debug, and govern, especially in environments where multiple agents or workflows coexist.

From Labs to Hackathon

Following the labs, participants transitioned into a hackathon format. The challenge was to apply ADK principles to a real problem and deliver a working solution within a limited timeframe.

The judging criteria strongly favored:

Practical relevance over novelty
Architectural clarity over complexity
Responsible use of agent capabilities
Technical soundness and scalability

This created a setting where well-structured systems stood out immediately, and loosely defined agent demos did not.

Building a DataOps Agent with ADK

Our team focused on a persistent challenge in modern data platforms: making large-scale analytical data easier to explore and operate without deep SQL expertise.

Despite the availability of powerful data warehouses such as BigQuery, many users still struggle to extract insights from complex datasets. Writing correct and efficient SQL, understanding schemas, and navigating massive tables remain significant barriers.

Our goal was to build a DataOps-focused AI agent that could translate natural language questions into structured analytical queries, execute them safely, and return meaningful insights, all while remaining aligned with production constraints.

The project is publicly available here: https://github.com/mikaeelkhalid/dataops-adk-agent

Project Purpose and Scope

The DataOps ADK Agent is an AI-driven analytical assistant designed to help analysts and engineers interact with large datasets using natural language. The agent operates on top of BigQuery, specifically leveraging the public GitHub repositories dataset, and enables users to ask questions such as:

Top programming languages by code size in a repository
Most active contributors over a given time period
Commit and file-level insights across projects
Pattern-based file searches with contextual results

Rather than acting as a generic chatbot, the agent is designed as a structured analytical system.

Architecture Overview

The project implements a multi-stage agent pipeline using ADK, where each stage has a clear responsibility:

SQL Generator Agent Converts natural language queries into structured, parameterized SQL.
Query Explainer Agent Interprets the generated query, estimates cost implications, and provides human-readable explanations.
Query Executor Agent Executes the validated SQL against BigQuery and retrieves results.

This staged approach ensures separation of concerns and improves reliability. Each agent reasons independently, while the overall workflow remains deterministic and observable.

Data Sources and Operational Context

The agent operates on the BigQuery public GitHub dataset, which contains detailed information about millions of open-source repositories, including commits, files, languages, and metadata.

By grounding the agent in an authoritative, structured dataset, the system avoids hallucination and ensures that responses are based on real, queryable data rather than inferred knowledge.

Technology Stack

The project integrates several production-grade components:

Python 3.12+ for agent orchestration
Google Agent Development Kit (ADK) for agent logic and workflow control
BigQuery as the analytical backend
Streamlit for an interactive user interface
Docker and Docker Compose for containerized execution
Terraform for infrastructure provisioning
Vertex AI Agent Engine for managed, scalable deployment

This combination supports both local development and cloud-native execution.

User Interaction and Execution Flow

Users interact with the system through a Streamlit interface, submitting natural language questions. The agent pipeline then:

Interprets the question and generates SQL
Explains the query and its intent
Executes the query safely in BigQuery
Returns structured results and summaries

At no point does the agent directly manipulate infrastructure or data without going through explicit, controlled execution paths.

Why ADK Was Critical

ADK played a decisive role in shaping the solution. Its emphasis on structure enforced several beneficial constraints:

Clear separation between reasoning and execution
Predictable agent behavior
Easier debugging and demonstration
Alignment with production safety requirements

These constraints did not limit the agent’s usefulness. Instead, they made it more reliable and credible in a real-world setting.

Hackathon Outcome

The project stood out because it addressed a real analytical problem using AI agents in a responsible and technically sound way. The clarity of the architecture, combined with practical applicability and deployment readiness, resonated strongly with the judges.

As a result, the project won the hackathon, validating both the problem choice and the system design.

Key Learnings

Several important lessons emerged from this experience:

Effective AI agents are system components, not conversational toys
Structure and guardrails enable scalability and trust
Data and operations are strong candidates for agent-based augmentation
Architecture matters more than model choice

Most importantly, the event reinforced that production-ready AI agents require the same level of rigor as any other critical system.

Conclusion

Google AI Agents Live + Labs Benelux 2025 provided a clear view into how Google envisions the future of agent-based systems. The hands-on experience with ADK demonstrated that disciplined design, explicit boundaries, and structured workflows are essential for building agents that can operate safely in real environments.

Our DataOps ADK Agent project showed that when agents are grounded in authoritative data, constrained by clear contracts, and supported by robust infrastructure, they can deliver meaningful value and stand out even in competitive settings.