Making sense of Google’s agentic dev tools

2026-07-15T03:15:14-04:00

Google released a few cool new AI-assisted developer toys recently. Have you tried them? Do you know which one to use and when? That’s the goal of this talk, to make sense of those new agentic dev tools. First, we'll start playing with Google AI Studio, to get a sense of the existing models and agents developers can pick up, and we'll see how you can quickly get started vibe-coding apps easily and deploy them in the cloud. Next, we’ll discover Stitch, an AI-powered tool which helps app builders create high-quality user interfaces for mobile and web apps. You can then eventually export them to vibe code a first prototype with Google AI Studio. We will look at Antigravity, a new kind of IDE where the main view is actually your AI agent manager dashboard. You plan the work, and autonomous agents execute the tasks. Of course, anytime, you can switch to the more classic code editor with all the smart completions you’d expect. Last is Jules, a coding agent that lives in the cloud. You can assign Jules boring tasks (fixing bugs or updating tests) and it will work in the background to send you a Pull Request when it is finished. Join me to see how these tools work in real life. You will leave knowing how to speed up your development and how to become a great boss for your new robot interns!

Building AI Agents with ADK (Agent Development Kit) for Java

2026-07-05T07:58:26-04:00

Buzzword of the year, AI agents are becoming mainstream. You don’t even need to use Python to create agents, you can develop them using Java! In this presentation, we’ll focus in particular on one framework: ADK, the Agent Development Kit released by Google. AI Agents perceive, decide, and act to achieve goals using LLMs and tools. We’ll explore the various tools at our disposal, including built-in ones like Google Search or sandboxed code execution, as well as custom Java code, or MCP servers. To make agents even smarter, skills can teach them the right knowledge and procedures to follow for complex actions. Multi-agent systems can be built by delegating tasks to more specialized sub-agents. We’ll see the various patterns at play to organize agents to work together, using sequential, parallel, or loop flows. Or how you can interact with remote A2A (Agent2Agent Protocol) agents or expose your own via A2A. Also, some multi-agent scenarios require more agency, and Goal Oriented Action Planning gives more flexibility to your systems. That’s not all, we’ll also look into how callbacks allow you to plug into the AI agent workflow (including for hooking up guardrails), or how state can be shared and manipulated, and how events flow in our agentic systems or how they are persisted in memory. At the end of this presentation, you’ll know everything about ADK for Java, and you’ll be able to build your first AI agents in no time!

Agentic Design Patterns

2026-05-26T09:26:59-04:00

Time to dive a little deeper, beyond the usual AI agent intros. When building your multi-agent systems, you’ll often be combining basic bricks like sequential, parallel, or loop flows. With those components, you create more complex patterns, like reflection loops, and reviewer/critique agents. However the path to AI-nlightment might require you to make choices with the routing pattern, or to shepherd a swarm of agents to collaborate together. We'll also have a look at patterns like progressive disclosure (used by agent skills), goal-oriented-action-planning for defining goals agents have to attain, and we'll even experiment with building our own custom coding agent loop. As a committer on both LangChain4j and ADK for Java (Agent Development Kit), it’ll be my pleasure to guide you through this agentic adventure, and help you make the right choices and use the right abstractions on your journey.

Making sense of Google’s agentic dev tools

2026-04-23T07:41:33-04:00

Google released a few cool new AI-assisted developer toys recently. Have you tried them? Do you know which one to use and when? That’s the goal of this talk, to make sense of those new agentic dev tools. We will look at Antigravity, a new kind of IDE where the main view is actually your AI agent manager dashboard. You plan the work, and autonomous agents execute the tasks. Of course, anytime, you can switch to the more classic code editor with all the smart completions you’d expect. We’ll discover Stitch, an AI-powered tool which helps app builders create high-quality user interfaces for mobile and web apps. You can then eventually export them to vibe code a first prototype with Google AI Studio. Next is Jules, a coding agent that lives in the cloud. You can assign Jules boring tasks (fixing bugs or updating tests) and it will work in the background to send you a Pull Request when it is finished. Finally, we will try out the Gemini CLI, which brings these smart assistants right into your terminal. But it’s not just about code, it’ll be your Swiss Army knife for all kinds of tasks! Join me to see how these tools work in real life. You will leave knowing how to speed up your development and how to become a great boss for your new robot interns!

Choose your own adventure in agentic design patterns

2026-04-23T07:31:48-04:00

Time to dive a little deeper, beyond the usual AI agent intros. When building your multi-agent systems, you’ll often be combining basic bricks like sequential, parallel, or loop flows. With those components, you create more complex patterns, like reflection loops, LLM-as-Judge, reviewer/critique agents, and coding agents in loops. However the path to AI-nlightment might require you to make choices with the routing pattern, or to shepherd a swarm of agents to collaborate together. And even beyond that, with MCP and A2A, you might be able to create a swarm of remote agents! As a committer on both LangChain4j and ADK for Java (Agent Development Kit), it’ll be my pleasure to guide you through this agentic adventure, and help you make the right choices and use the right abstractions on your journey.

Standards et agents IA : un tour d’horizon de MCP, A2A, ADK et plus encore

2026-04-22T09:25:25-04:00

Les fondations des agents IA reposent sur une poignée de protocoles communs que vous devez maîtriser pour tirer le meilleur parti de votre LLM et de votre framework agentique. C’est pourquoi il est important de les comprendre. Certains gagnent du terrain, d’autres non. Dans ce deep dive, nous explorerons l’écosystème en vous présentant ces standards et en nous concentrant sur les plus importants. Connaître certains frameworks est également utile pour démarrer plus rapidement. Bienvenue aux protocoles MCP, A2A, ACP, et aux frameworks ADK, Arc, Quarkus, LangChain4j ! Après un aperçu des principaux standards et protocoles, nous commencerons par construire un agent, d'abord sans protocole, puis en ajoutant des interactions MCP. Nous construirons après un système multi-agents et multi-technos (ADK, Quarkus et LangChain4j) via A2A. Vous apprendrez ce que font ces protocoles et comment ils fonctionnent, mais aussi pourquoi ils sont importants, avec des parcours détaillés et des démos en direct tout au long de la session. Si vous avez du mal à comprendre tous les détails des protocoles autour des agents IA, cette session est faite pour vous !

Webhook best practices for rock solid and resilient deployments

2026-02-04T09:00:26-05:00

Webhooks facilitate real-time, event-driven communication between systems but require a defensive architecture to ensure security, reliability, and scalability. Unlike polling, webhooks utilize a "push" model, necessitating robust handling of network partitions, malicious activity, and traffic spikes. Security and Authentication Security implementation must go beyond obscured URLs. The industry standard involves HMAC-SHA256 signature verification to ensure payload integrity and authenticity. Critical implementation details include using constant-time string comparisons to prevent timing attacks and validating raw, unparsed payloads. To prevent replay attacks, systems should enforce timestamp tolerance windows and utilize nonces. While Mutual TLS (mTLS) offers a higher security standard for zero-trust environments, it introduces significant complexity compared to signatures and IP allowlisting. Reliability and Architecture Because webhooks typically guarantee "at-least-once" delivery, receivers must implement idempotency using unique event keys and atomic storage to prevent duplicate processing from corrupting data. To handle high throughput and avoid timeouts, architectures should be asynchronous: an ingestion layer should immediately acknowledge requests (returning 202 Accepted) and offload the payload to a message queue for background processing by workers. Failure Handling and Recovery Robust systems employ exponential backoff with jitter for retries to prevent "thundering herd" scenarios that could overwhelm the receiver. Messages that fail all retry attempts should be routed to a Dead Letter Queue (DLQ) for inspection and potential redrive rather than being discarded. Additionally, circuit breakers are essential to pause delivery to failing endpoints, protecting the infrastructure from cascading failures during outages. Scalability and Payload Design To manage bursty traffic, providers should enforce rate limiting and buffering. Payload design involves a trade-off between "Fat" payloads (full state, convenient but larger attack surface) and "Thin" payloads (notifications only, secure but require callback API calls). Best practices suggest keeping payloads under 20kb, minimizing PII, and utilizing additive versioning per event type to maintain backward compatibility.

AI Agent Standards and Protocols: a Walkthrough of MCP, A2A, and more...

2026-01-15T04:58:31-05:00

AI agent foundations are built over a handful of common protocols that you need to master, to make the best out of your LLM and agent framework. That’s why it’s important to understand them. But some are catching up, others are not. In this deep dive, we will explore the ecosystem showing you these standards and focusing on the important ones. Knowing some of the frameworks is useful too to get started faster. Welcome MCP, A2A, ACP protocols, and ADK, Arc, Quarkus, LangChain4j frameworks! After giving you an overview of the main standards and protocols, their merit and their popularity, we will start by building an agent using Agent Development Kit (ADK) and walk through making a tool call. From there, zooming on MCP, we’ll see how to standardize that tool via a local MCP server and then deploy it as a remote MCP server to share it with others. Next, we’ll dive into the A2A protocol and enable our agent to participate in multi-agent conversations. And to do that, we will use another framework, Quarkus and LangChain4j, showing how different stacks interact seamlessly through A2A. You’ll learn not just what these protocols do and how they work, but why they matter, with detailed walkthroughs and live demos throughout. If you’re struggling to understand all the protocol details around AI agents, this session is for you!

Agentic AI Patterns and Anti-Patterns

2025-12-03T12:19:53-05:00

AI Agents are the buzzword of the year. Yet relying on the magic of autonomy remains risky due to hallucinations and planning errors. After a quick overview of the agent personas, and defining the agent equation, we'll go through architectural patterns like the conductor for task supervision, rethinking tools for lower hallucination rates, and using proven and promising protocols like Model Context Protocol (MCP) for standardizing tools and Agent 2 Agent protocol (A2A) to foster an ecosystem of agents. We will also dismantle common anti-patterns, such as the leadership's chatbot mandate instead of augmented UIs, the silent confabulation where users can't trust the agent responses, and showing you how to build systems that focus on verifiable results and real business value.

Agents IA : la nouvelle frontière des LLMs (Tech.Rocks Summit 2025)

2025-12-02T03:27:18-05:00

Buzzword de 2025, les agents IA ont fait couler beaucoup d’octets. Nous verrons ensemble les ingrédients clés de la recette : les modèles qui raisonnent, les outils et protocoles utilisés (function calling et MCP), comment orchestrer des agents ensemble (ADK, A2A), en passant par les patterns importants.

Building AI Agents with ADK for Java

2025-10-10T06:29:48-04:00

Buzzword of 2025, AI agents are becoming mainstream. You don’t even need to use Python to create agents, you can develop them using Java! In this presentation, we’ll focus in particular on one framework: ADK, the Agent Development Kit released by Google. AI Agents perceive, decide, and act to achieve goals using LLMs and tools. We’ll explore the various tools at our disposal, including built-in ones like Google Search or sandboxed code execution, as well as custom Java code, or MCP servers. Multi-agent systems can be built by delegating tasks to more specialized sub-agents. We’ll see the various patterns at play to organize agents to work together, using sequential, parallel, or loop flows. That’s not all, we’ll also look into how callbacks allow you to plug into the AI agent workflow, or how state can be shared and manipulated, and how events flow in our agentic systems or how they are persisted in memory. At the end of this presentation, you’ll know everything about ADK for Java, and you’ll be able to build your first AI agents in no time!

AI Agents, the new Frontier for LLMs

2025-09-17T07:21:09-04:00

Know Large Language Models at your fingertips? Mastering Retrieval Augmented Generation to help an LLM search your documents? It's time to dive into the wonderful world of intelligent agents, the next frontier for LLMs! In this session, we will first define what agents are, or at least what makes a system "agentic". We will explain the limitations of LLMs, key agent characteristics and patterns. Then, through concrete examples, we will implement various agents in Java, using the LangChain4j and ADK frameworks, to illustrate some typical agent patterns and to understand how to go beyond a simple LLM call to obtain responses that meet the needs of your users, or even to trigger actions with the surrounding system. Are you ready for the next hype on agents? Come and discover it in this session!

Things you never dared to ask about LLMs — v2

2025-05-26T06:19:56-04:00

Large Language Models (LLMs) have taken the world by storm, powering applications from chatbots to content generation. Yet, beneath the surface, these models remain enigmatic. This presentation will “delve” into the hidden corners of LLM technology that often leave developers scratching their heads. It’s time to ask those questions you’ve never dared ask about the mysteries underpinning LLMs. Here are some questions we’ll to answer: Do you wonder why LLMs spit tokens instead of words? Where do those tokens come from? What’s the difference between a “foundation” / “pre-trained” model, and an “instruction-tuned” one? We’re often tweaking (hyper)parameters like temperature, top-p, top-k, but do you know how they really affect how tokens are picked up? Quantization makes models smaller, but what are all those number encodings like fp32, bfloat16, int8, etc? LLMs are good at translation, right? Do you speak the Base64 language too? We’ll realize together that LLMs are far from perfect: We’ve all heard about hallucinations, or should we say confabulations? What is this reversal curse that makes LLMs ignore some facts from a different viewpoint? You’d think that LLMs are deterministic at low temperature, but you’d be surprised by how the context influences LLMs’ answers… Buckle up, it’s time to dispel the magic of LLMs, and ask those questions we never dared to ask!

AI Agents — the new frontier for LLMs

2025-05-12T00:12:03-04:00

Know Large Language Models at your fingertips? Mastering Retrieval Augmented Generation to help an LLM search your documents? It's time to dive into the wonderful world of intelligent agents, the next frontier for LLMs! In this session, we will first define what agents are, or at least what makes a system "agentic". We will explain the limitations of LLMs. Then, through concrete examples, we will implement different agents in Java, using the LangChain4j framework, to illustrate some typical agent patterns and to understand how to go beyond a simple LLM call to obtain responses that meet the needs of your users, or even to trigger actions with the surrounding system. But it’s not all we’ll learn about! An agent doesn’t live alone on a desert tropical island. Indeed it can communicate with other agents via tools that can be invoked thanks to the Model Context Protocol (MCP). They can also interact with other remote agents from other platforms and ecosystems, thanks to the Agent To Agent protocol (A2A). Are you ready for the next hype on agents? Come and discover it in this session!

Things you never dared to ask about LLMs

2024-10-19T08:48:35-04:00

Do you wonder why LLMs spit tokens instead of words? Where do those tokens come from?
What’s the difference between a “foundation” / “pre-trained” model, and an “instruction-tuned” one?
We’re often tweaking (hyper)parameters like temperature, top-p, top-k, but do you know how they really affect how tokens are picked up?
Quantization makes models smaller, but what are all those number encodings like fp32, bfloat16, int8, etc?
LLMs are good at translation, right? Do you speak the Base64 language too?

We’ll realize together that LLMs are far from perfect:

We’ve all heard about hallucinations, or should we say confabulations?
What is this reversal curse that makes LLMs ignore some facts from a different viewpoint?
You’d think that LLMs are deterministic at low temperature, but you’d be surprised by how the context influences LLMs’ answers…

Buckle up, it’s time to dispel the magic of LLMs, and ask those questions we never dared to ask!

From naive to advanced RAG: the complete guide

2024-10-11T11:31:39-04:00

It’s easy to get started with Retrieval Augmented Generation, but you’ll quickly be disappointed with the generated answers: inaccurate or incomplete, missing context or outdated information, bad text chunking strategy, not the best documents returned by your vector database, and the list goes on.After meeting thousands of developers across Europe, we’ve explored those pain points, and will share with you how to overcome them. As part of the team building a vector database we are aware of the different flavors of searches (semantic, meta-data, full text, multimodal) and embedding model choices. We have been implementing RAG pipelines across different projects and frameworks and are contributing to LangChain4j.In this deep-dive, we will examine various techniques using LangChain4j to bring your RAG to the next level: with semantic chunking, query expansion & compression, metadata filtering, document reranking, data lifecycle processes, and how to best evaluate and present the results to your users.

RAG: from dumb implementation to serious results

2024-10-11T11:15:08-04:00

Embarking on your RAG journey may seem effortless, but achieving satisfying results often proves challenging. Inaccurate, incomplete, or outdated answers, suboptimal document retrieval, and poor text chunking can quickly dampen your initial enthusiasm. In this session, we'll leverage LangChain4j to elevate your RAG implementations. We'll explore: * Advanced Chunking Strategies: Optimize document segmentation for improved context and relevance. * Query Refinement Techniques: Expand and compress queries to enhance retrieval accuracy. * Metadata Filtering: Leverage metadata to pinpoint the most relevant documents. * Document Reranking: Reorder retrieved documents for optimal result presentation. * Data Lifecycle Management: Implement processes to maintain data freshness and relevance. * Evaluation and Presentation: Assess the effectiveness of your RAG pipeline and deliver results that meet user expectations. Join us as we transform your simplistic RAG experience from one of frustration to delight your users with meaningful and accurate answers.

Gemini, Google's Large Language Model

2024-04-25T05:22:38-04:00

Gemini is the large multimodal model powering the Gemini app, but you can also use its API through Google Cloud and integrate it into your applications. Gemini offers different sizes, from Nano to Ultra, including Pro. Its unique feature is its multimodality: you can give it text, images, or videos! This opens up new use cases for you. In this presentation, we will explore the Gemini model (and its little “open-weights” model sister, Gemma). With our Java hats on, we will learn how to use its API, especially with the LangChain4j library. How to get the most out of Gemini? We will see how to extract unstructured data, how to classify text, how to extend the model's knowledge with the RAG (Retrieval Augmented Generation) approach, and how to use "function calls" to invoke external services when generating text. Hold on tight! The Gemini capsule is about to take off!