Agent Development Kit for Java
A Java toolkit for coding, composing, and deploying tool-using AI agents.
Per-dimension scores and reasoning
Evidence shows the repository is published by Google's official organization, with clear source attribution (source_attribution=2). However, no specific implementations or documentation for least privilege, user confirmation, data flow transparency, sensitive data handling, dependency security, external effects, or rollback mechanisms were found, so these criteria score 0.
The features described in the README are largely consistent with the code examples, but no detailed error handling or failure message documentation is provided (failure_messages=0). Dependency availability is indicated by Maven Central and JitPack references, but no dependency list or verification is provided (dependency_availability=1).
The README clearly identifies the target audience (Java developers) and typical scenarios (building, evaluating, deploying AI agents), but does not detail capability boundaries or trigger conditions (capability_boundaries=1, trigger_precision=0). Environment fit is addressed with mentions of Google Cloud integration, but detailed deployment environment requirements are not provided (environment_fit=2).
Information architecture is clear, with documentation, samples, and contribution guidelines (information_architecture=2). Installation notes are specific (Maven coordinates), but detailed installation steps or troubleshooting are not provided (install_notes=2). Naming stability is indicated by version numbers, but no naming conventions or API stability statements are given (naming_stability=1). Examples and FAQ provide code examples but no FAQ (examples_and_faq=2). Known limitations are mentioned with 'Pre-GA' status, but not detailed (known_limitations=1). License is Apache-2.0 with full text present (license=3). Versioning is present but no changelog is provided (versioning_changelog=1). Maintenance responsibility is indicated by contribution guidelines and GitHub Actions (maintenance_responsibility=2).
Output usability is supported by code examples and documentation links, but no actual output examples are provided (output_usability=1). Marginal value is high as an official Google tool with Google ecosystem integration (marginal_value=2). Cost-benefit is open-source and free, but no performance or resource consumption data is provided (cost_benefit=1).
Claim traceability is weak; feature claims in the README lack specific implementation or test evidence (claim_traceability=1). Cross-source corroboration is limited to documentation and sample links, with no independent verification (cross_source_corroboration=1). Fact-inference separation is poor; README descriptions are mostly assertions without distinguishing facts from inferences (fact_inference_separation=1).
- Static review found no concrete implementations of security mechanisms (e.g., permission controls, user confirmation, data flow transparency); further code review is needed.
- The 'Evaluate Agents' feature claimed in the README is marked as 'Coming soon', so actual availability is unknown.
- Dependency security is unverified; dependency lists and known vulnerabilities need to be checked.
What does this agent do, and when should you use it?
Agent Development Kit for Java is an open-source Java toolkit for building, evaluating, and deploying sophisticated AI agents. It keeps agent behavior, orchestration, and tool use in Java code, so those definitions can be debugged and versioned alongside an application. Its shown API constructs an agent with `LlmAgent.builder()`, including a model, instructions, and tools. The project supports hierarchical systems composed of specialized agents and describes a built-in development UI for testing, evaluating, debugging, and showcasing them. It is aimed at applications closely integrated with Google Cloud services, while the README says deployments can span a laptop and the cloud.
A developer creates an LlmAgent in Java with LlmAgent.builder(), supplies .name(), .description(), .model(), .instruction(), and .tools(), then calls .build(). The supplied example creates search_assistant with the gemini-2.0-flash model, a response instruction, and GoogleSearchTool so it can use Google Search when needed. Tools may come from built-in tools, custom functions, OpenAPI specifications, or existing-tool integrations, and specialized agents can be composed into hierarchies. The project also states that it integrates with the A2A protocol for remote agent-to-agent communication, although the supplied material does not include the setup or invocation details.
- A Java engineering team that wants agent instructions, model selection, and tool calls reviewed and versioned as application code.
- A team building an application tightly integrated with Google Cloud services that needs an agent framework in Java.
- A developer creating a Java search assistant with
GoogleSearchToolfor web lookups when answering users. - An engineering group composing specialized agents into a hierarchical multi-agent application.
- A developer who wants a built-in development UI to test, debug, evaluate, or demonstrate an agent.
What are this agent's strengths and limitations?
- Agent behavior, orchestration, and tool use are defined directly in Java, making them suitable for code-based testing, debugging, and versioning.
- It names several tool-integration paths: built-in tools, custom functions, OpenAPI specifications, and existing tools.
- It supports hierarchical multi-agent systems composed of specialized agents.
- It explicitly describes an A2A-protocol integration path for remote agent-to-agent communication.
- The project is designed for applications closely integrated with Google Cloud services, so other ecosystems may require additional integration work.
- The README labels agent evaluation as “Coming soon,” so a usable evaluation workflow is not established by the supplied material.
- The supplied material does not specify a Java version, model credentials, execution command, or deployment configuration.
- A2A setup is delegated to another README that was not supplied, leaving its end-to-end configuration unverified here.
How do you install or deploy this agent?
The documented Maven dependency is:
<dependency>
<groupId>com.google.adk</groupId>
<artifactId>google-adk</artifactId>
<version>1.7.0</version>
</dependency>
For the development UI, also add com.google.adk:google-adk-dev:1.7.0. The supplied material does not specify a Java version, credentials, a runtime command, or deployment configuration.
How do you use this agent?
The supplied first construction example is: LlmAgent rootAgent = LlmAgent.builder().name("search_assistant").description("An assistant that can search the web.").model("gemini-2.0-flash").instruction("You are a helpful assistant. Answer user questions using Google Search when needed.").tools(new GoogleSearchTool()).build(); This builds an agent definition; the supplied material does not document how to execute it, configure model credentials, or launch the development UI.
How does this agent compare with similar options?
The README positions this as having the same features and a familiar interface relative to Python ADK. Teams already familiar with Python ADK may find the Java LlmAgent builder approach easier to recognize.
FAQ
Is it limited to Gemini models?
gemini-2.0-flash, but its comment says “Or your preferred models.” The supplied material does not list supported models or their configuration.