Google’s Agent Development Kit for Java has reached a significant milestone with the release of version 1.0. This update introduces a range of new features and improvements that make it easier for developers to build and deploy intelligent agents. With the ADK for Java 1.0, developers can now create more sophisticated and efficient agents that can interact with a wider range of tools and systems.
11 Essential Features of Google ADK for Java 1.0 You Need to Know
One of the key benefits of the ADK for Java 1.0 is its support for new external tools. The GoogleMapsTool, for example, provides access to Google Maps data, while the UrlContextTool can fetch and summarize web content directly. The ContainerCodeExecutor and VertexAICodeExecutor enable robust code execution locally using Docker containers or in the Cloud with Vertex AI, respectively.
1. GoogleMapsTool and UrlContextTool
The GoogleMapsTool and UrlContextTool are two new external tools that have been added to the ADK for Java 1.0. These tools provide developers with access to a wider range of data and functionality, making it easier to build and deploy intelligent agents. The GoogleMapsTool, for example, allows developers to access Google Maps data, such as street views and satellite imagery. This can be particularly useful for applications that require location-based data, such as route planning or real estate applications.
The UrlContextTool, on the other hand, can fetch and summarize web content directly. This can be useful for applications that require access to specific web pages or data, such as news aggregators or social media monitoring tools.
2. ContainerCodeExecutor and VertexAICodeExecutor
The ContainerCodeExecutor and VertexAICodeExecutor are two new tools that enable robust code execution locally using Docker containers or in the Cloud with Vertex AI, respectively. These tools allow developers to execute code in a more efficient and scalable manner, making it easier to build and deploy complex applications.
The ContainerCodeExecutor uses Docker containers to execute code locally, while the VertexAICodeExecutor uses Vertex AI to execute code in the Cloud. This provides developers with a range of options for executing code, depending on their specific needs and requirements.
3. App Class and Plugins
The ADK for Java 1.0 also introduces two new APIs: the App class and Plugins. The App class is a top-level container for agentic applications that hosts the root agent, holds global configurations, and handles plugin integration. The Plugins base class defines new extensions, and some plugins are available out of the box, including LoggingPlugin, ContextFilterPlugin, and GlobalInstructionPlugin.
The App class provides developers with a flexible and customizable way to build and deploy agentic applications. The Plugins base class, on the other hand, allows developers to define new extensions and customize the behavior of their applications.
4. Event Compaction
Event compaction is a fundamental context engineering practice that helps manage an agent’s context size by “keeping only a sliding window of the last events and/or summarizing older events”. This is a useful feature for preventing context windows from growing beyond token limits while also reducing latency and costs in long-running sessions.
The event compaction API allows developers to control the compaction interval, token threshold, overlap size, event retention limits, and the summarizer to use. This provides developers with a high degree of flexibility and customization when it comes to managing their agent’s context size.
5. Human-in-the-Loop Workflows
The ADK for Java 1.0 also supports human-in-the-loop workflows, which allow developers to pause before taking critical actions, request approval, and then resume execution. This is a useful feature for applications that require human oversight or approval, such as financial transactions or medical diagnoses.
A registered tool can access its ToolContext and call requestConfirmation(). This automatically intercepts the run, pausing the LLM flow until input is received. The ADK automatically cleans up intermediate events and explicitly injects the confirmed function call into the subsequent LLM request context.
6. Agent2Agent (A2A) Protocol
The ADK for Java 1.0 natively supports the Agent2Agent (A2A) protocol, which enables different agents to communicate and collaborate, even across different languages or frameworks. To expose your own ADK agents via the A2A Protocol, you create an A2A AgentExecutor. It wraps your ADK agents and exposes them via a JSON-RPC REST endpoint, instantly making your ADK creations accessible to the wider A2A ecosystem.
7. Official A2A Java SDK Client
The ADK for Java integrates the official A2A Java SDK Client, which provides developers with a range of tools and APIs for building and deploying A2A-enabled agents. This includes APIs for creating and managing agents, as well as tools for debugging and testing.
8. JSON-RPC REST Endpoint
The A2A AgentExecutor exposes ADK agents via a JSON-RPC REST endpoint, making it easy for developers to integrate their agents with other systems and applications. This provides developers with a flexible and scalable way to build and deploy complex applications that require agent-based functionality.
9. Type Safety
One of the key benefits of the ADK for Java is its type safety, which makes it easier for developers to catch orchestration bugs early and potentially making Java agents more stable at scale than their Python counterparts.
10. GitHub Availability
The ADK for Java can be downloaded from GitHub, making it easy for developers to access and start using the latest version of the ADK. This provides developers with a flexible and scalable way to build and deploy agentic applications.
11. Community Support
The ADK for Java has a growing community of developers and contributors who provide support and resources for building and deploying agentic applications. This includes forums, documentation, and tutorials, as well as a range of tools and APIs for building and deploying agents.
Conclusion
The ADK for Java 1.0 is a significant update that provides developers with a range of new features and improvements for building and deploying intelligent agents. With its support for new external tools, event compaction, human-in-the-loop workflows, and Agent2Agent (A2A) protocol, the ADK for Java 1.0 is a powerful tool for developers who want to build and deploy complex applications that require agent-based functionality.
By following the guidelines and best practices outlined in this article, developers can get the most out of the ADK for Java 1.0 and build and deploy complex applications that meet their specific needs and requirements.
