Google ADK CLI: The Fastest Way to Build and Ship AI Agents in 2026 [Guide]

Google's Agent Development Kit just crossed 20,000 stars on GitHub, and the Google ADK CLI is quietly becoming the fastest path from "I have an idea for an agent" to "it's running in production." ADK Python 2.0 hit General Availability with graph workflows, collaborative multi-agent support, and a CLI-first deployment pipeline that makes competing frameworks feel like they were designed by committee.

I've been building agents with various frameworks for the past year. LangChain, CrewAI, AutoGen, Claude Code. Each has strengths. But ADK's combination of a clean CLI workflow, reusable Skills, and a deployment path that doesn't require you to become a Kubernetes expert? It's the first time I've felt like the tooling actually matches the ambition of what agents can do.

Here's how the whole pipeline works, from install to deployment.

What Is the Google ADK CLI and Why Does It Matter?

Google's Agent Development Kit is an open-source, code-first toolkit for building, evaluating, and deploying AI agents. The Google ADK CLI is the command-line interface baked into the framework that lets you scaffold projects, run agents locally, and deploy them to Google's Agent Platform. All without leaving your terminal.

What makes this different from yet another agent framework? Three things.

First, ADK is genuinely multi-model. It supports Gemini, Gemma, Claude (via Vertex), Ollama, vLLM, LiteLLM, and LiteRT-LM. You're not locked into Gemini. You can route different agent tasks to different models based on cost, latency, or capability. This matters in production, where your summarization agent absolutely doesn't need the same model as your code generation agent.

Second, five languages: Python, TypeScript/JavaScript, Go, Java, and Kotlin. Claude Code is TypeScript-primary. OpenAI's Codex CLI is Python/JS. ADK meets enterprise teams where they already are.

Third, the deployment spectrum is sane. Agent Platform (fully managed via agents-cli), Cloud Run (container-based), and GKE (full Kubernetes control). Pick the level of operational complexity you're willing to own.

The best agent framework is the one that gets out of your way between "this works on my laptop" and "this works in production." ADK is the first one I've used where that gap doesn't feel like a chasm.

How to Install ADK and Create Your First Agent

Installation is a single pip command. No Docker setup, no environment wrangling, no multi-step bootstrapping ritual.

Run pip install google-adk and you're ready. ADK requires Python 3.9+ and handles its own dependency tree cleanly. I can't say that about every framework I've used.

The project scaffolding follows a convention-over-configuration pattern. You create a directory for your agent, add an __init__.py and an agent.py, and define your agent's model, instructions, and tools. The structure is intentionally minimal: no YAML sprawl, no config files referencing other config files.

Your agent definition is pure Python. You import Agent from google.adk.agents, specify your model (say, gemini-2.5-flash), write your system instructions as a string, and attach your tools as a list. The entire agent definition fits in a single file that any Python developer can read without consulting documentation.

After setting your GOOGLE_API_KEY environment variable, you run your agent with adk run your_agent_directory/. The CLI starts an interactive session where you can send messages and watch the agent reason, call tools, and respond. No web server to spin up, no port forwarding, no browser tabs. Just your terminal.

Having built agents with LangChain and OpenAI before, the difference in friction is stark. ADK's CLI-first approach means you're testing agent behavior within 60 seconds of writing your first tool function. With most other frameworks, I was still fighting imports at that point.

ADK also ships a web interface (adk web) for visual debugging and a Visual Builder for no-code agent design. But the CLI is where serious development happens.

How Do ADK Skills Work?

Skills are where ADK gets interesting in a way that actually matters for production systems. An ADK Skill is a reusable capability bundle that your agent can call. Think of it as a portable, composable unit of agent behavior that wraps tools, knowledge, and procedures into a single deployable package.

A Skill can wrap three types of tools: Function tools (pure Python functions you write), MCP tools (connections to external services via the Model Context Protocol), and OpenAPI tools (any REST API with an OpenAPI spec). Build a Skill once, share it across multiple agents, stop duplicating code.

The architecture maps to what other ecosystems are doing. As developer Rapls explains in a detailed breakdown on Dev.to, Claude Code uses a nested model: Skills (procedure bundles) → MCP (external connectivity) → Plugins (distribution containers). Google ADK's architecture follows a similar shape: Tools/Skills → MCP tools (via ADK's native MCP integration) → Agent deployments (via agents-cli). The concepts are converging across the industry, which is a good sign for portability.

I've built enough multi-tool agents to know what happens without this kind of abstraction. You end up with agents that have 30 tool functions in a single file, no clear boundaries, and no way to test individual capabilities in isolation. Skills force you to think in composable units. Your "search the web" Skill is separate from your "query the database" Skill, and each can be versioned, tested, and swapped independently. This is one of those things where the boring answer — just organize your code properly — is actually the right one.

Skills also integrate with ADK's callback system, so you can add pre- and post-execution hooks for logging, permission checks, or human approval gates.

Google ADK CLI vs Claude Code vs OpenAI Codex CLI

The three dominant CLI-first agent frameworks right now target different developers and different problems. Here's how they actually stack up:

Google ADK CLI is a general-purpose agent framework. You define agents in code, attach tools and Skills, and deploy to managed infrastructure. It's built for agents that do things: automate workflows, process data, interact with APIs. The agents-cli deployment path handles infrastructure provisioning, and the built-in evaluation framework lets you test agent behavior systematically before shipping.

Claude Code is a coding-specific agent. It lives inside your IDE workflow and uses Skills as procedure/knowledge bundles that guide coding behavior. Its strength is deep code understanding and generation. But it's not a general-purpose agent builder. It's an AI pair programmer with extensibility hooks. If you need an agent that does anything other than write code, you're outside its design envelope.

OpenAI Codex CLI occupies a similar space to Claude Code: coding tasks, CLI-first execution. Lighter-weight but less flexible in terms of deployment targets and multi-model support.

Here's the thing nobody's saying about this comparison: the real differentiator is what happens after your agent works on your machine. Claude Code runs locally. Codex CLI runs locally. ADK agents can run locally and deploy to managed cloud infrastructure with observability, logging, metrics, and traces baked in. When I talk to teams who've struggled with AI agents in production, the gap is almost always between "works locally" and "works reliably at scale." ADK is the only CLI-first framework that treats deployment as a first-class concern.

That said, if you specifically need a coding agent, Claude Code is still the best tool for that job. Pick based on what you're actually building, not which framework has more GitHub stars.

How to Deploy ADK Agents to Production with agents-cli

Deployment is where most agent frameworks fall apart. You build something great locally, then spend two weeks writing Dockerfiles, configuring load balancers, and wiring up logging. ADK's agents-cli path eliminates most of that work.

The deployment documentation outlines three paths:

• Agent Runtime via agents-cli: Fully managed. Point the CLI at your agent code, and it handles containerization, deployment, scaling, and runtime management. This is the path for teams that want to ship fast and don't want to babysit infrastructure.
• Cloud Run: Container-based with auto-scaling. More control over the runtime, but you still avoid Kubernetes complexity. Good for custom dependencies or specific networking needs.
• GKE: Full Kubernetes deployment. For teams already running GKE clusters that want agents integrated into their existing infrastructure.

After deployment, ADK gives you structured logging, metrics dashboards, and distributed traces. You can test deployed agents through the CLI too, so your local dev workflow extends directly into production verification.

Here's a stat that should worry anyone shipping agents: according to a Business Insider report from June 2026, workers are spending over 6 hours per week "botsitting" AI agents. Manually supervising and correcting autonomous behavior. ADK's evaluation framework (criteria-based testing, user simulation, environment simulation) is designed to reduce exactly this kind of babysitting by catching bad agent behavior before deployment.

Graph Workflows and Collaborative Agents in ADK 2.0

The ADK 2.0 GA release introduced two features that separate it from the "just wrap an LLM with tools" category: graph workflows and collaborative multi-agent systems.

Graph workflows let you define deterministic execution paths that agents follow. You create graph routes (transitions between states), add data handling steps, insert human input gates where a person must approve before proceeding, and build dynamic workflows that adapt based on runtime conditions.

I've shipped enough features to know that "the LLM decides everything" is a recipe for unreliable behavior. Graph workflows let you put the deterministic skeleton in place — first gather data, then analyze, then get approval, then execute — while letting the LLM handle the creative reasoning within each step. It's the right balance between structure and flexibility, and it's the answer to the common complaint that LLM-powered agents are too unpredictable for production use.

Collaborative multi-agent workflows let multiple agents work together. Sequential workflows (Agent A finishes, then Agent B starts), parallel workflows (Agents A and B work simultaneously), and loop workflows (Agent A iterates until a condition is met). Agent routing dynamically assigns tasks to the most appropriate agent based on the request.

This is where ADK starts competing directly with frameworks like LangGraph and CrewAI. The template workflow system provides pre-built patterns for common multi-agent architectures, and you can customize or compose them for more complex scenarios.

One more thing: the safety layer. Given recent incidents where AI agents went rogue on production systems, this matters more than most people think. ADK includes action confirmations on function tools. Before your agent executes a destructive action, you can require human approval. For any agent operating on real infrastructure, this isn't a nice-to-have. It's table stakes.

What Comes Next for the Google ADK CLI

ADK 2.0 is GA, but the framework is moving fast. The GitHub repository has 497 open issues and 400 open pull requests. Those numbers signal both active community development and real-world edge cases getting surfaced.

The multi-language expansion is the most strategically significant move. With Kotlin support now available alongside Python, JavaScript, Go, and Java, Google is positioning ADK as the agent framework for enterprise teams. Most enterprises don't have the luxury of rewriting everything in Python. They need agents that integrate with existing Java services, Go microservices, or Kotlin Android apps.

My prediction: within 12 months, agents-cli becomes the default deployment mechanism for most Google Cloud AI workloads, the same way gcloud run deploy became the default for containerized services. The pattern is clear. Google builds opinionated CLI tooling, makes it the path of least resistance, then wraps managed services around it.

If you're evaluating agent frameworks right now, the question isn't whether ADK is the most feature-rich or the most battle-tested. It's whether you want a framework that treats the full lifecycle — build, test, evaluate, deploy, observe — as one integrated pipeline. Because that's what ADK gives you, and it's what most of the competition still doesn't.

Stop evaluating agent frameworks based on their demo tutorials. Start evaluating them based on what happens after the demo works.

Originally published on kunalganglani.com