Google Just Made a CLI That Turns Your Coding Assistant Into an Agent Deployment Machine

📖 13 min read

Quick Verdict: Google’s stack — Gemini CLI, the Agent Development Kit (ADK), the Agent2Agent (A2A) protocol, and Vertex AI’s Agent Engine — has quietly assembled into a full deployment pipeline. What used to be a coding assistant that finished your sentences can now scaffold, run, and ship multi-agent systems from the same terminal window. Rating: 8.5/10 — genuinely impressive, but you should know what you’re tying yourself to.

Discovered: April 2025 (ADK + A2A launch); updated June 2026

Most people heard about Google’s “Gemini CLI” and filed it next to Claude Code and Codex CLI — another terminal coding assistant. That categorization isn’t wrong, but it badly undersells what Google actually shipped. Over the course of 2025, Google stitched together four pieces — Gemini CLI, the Agent Development Kit (ADK), the Agent2Agent (A2A) protocol, and Vertex AI Agent Engine — into a continuous path from “I have an idea for an agent” to “this agent is running in production on Google Cloud, talking to other agents, and billing me by the millisecond.” None of these pieces on their own is novel. The pipeline is the story.

What Google Released

The story has four characters. It helps to know them separately before seeing how they fit together.

Gemini CLI is the entry point most developers first meet. Released in early July 2025, it’s an Apache 2.0 open-source terminal agent built by Google that puts Gemini — currently Gemini 3 — directly into your shell. The free tier is unusually generous: 60 requests per minute and 1,000 requests per day against a personal Google account, with a 1M-token context window. It bundles built-in tools for Google Search grounding, file operations, shell execution, and web fetching, and it speaks the Model Context Protocol (MCP), so any MCP server can extend it. You can install it three ways: npx @google/gemini-cli for a no-install run, npm install -g @google/gemini-cli for a permanent install, or brew install gemini-cli on macOS.

Agent Development Kit (ADK) is the framework layer. Google announced ADK on April 9, 2025, alongside A2A, and open-sourced the Python implementation as google/adk-python on GitHub under an Apache 2.0 license. ADK is a code-first, event-driven toolkit for building, evaluating, and deploying AI agents. It supports both workflow agents (deterministic pipelines) and LLM-coordinated dynamic agents (where the model decides what runs next). Critically, ADK is model-agnostic — you can swap in Gemini, Claude, or any LiteLLM-compatible backend — but it ships with first-class Gemini support and Google’s structured-output tooling. Recent versions added a Task API for structured agent-to-agent delegation with multi-turn task mode and human-in-the-loop approval.

Agent2Agent (A2A) is the missing connective tissue. Announced the same day as ADK, A2A is an open protocol that defines how autonomous agents from different vendors discover each other, negotiate capabilities via “Agent Cards,” and exchange tasks using JSON-RPC over HTTP(S). Google donated A2A to the Linux Foundation in June 2025 at Open Source Summit North America. A year later, the project counts more than 150 supporting organizations including AWS, Cisco, IBM, Microsoft, Salesforce, SAP, and ServiceNow. A2A is the reason an ADK-built agent can call out to a CrewAI agent on AWS or a LangGraph agent on Azure without anyone writing a custom adapter.

Vertex AI Agent Engine — recently rebranded as part of the Gemini Enterprise Agent Platform after Cloud Next 2026 — is the managed runtime. It’s a serverless environment where you push an ADK agent and Google handles deployment, scaling, session state, context caching, and observability. You don’t manage containers. You don’t pick instance types. You push code, you get an HTTPS endpoint, and you pay for what runs.

Four pieces. Terminal, framework, protocol, runtime. Hooked end to end.

Why It Matters: Coding Assistant → Agent Deployment Machine

Until recently, a “coding assistant” meant completion and chat. You wrote code, the model filled in the next line or answered a question in a side panel. Cursor, Claude Code, and the early Gemini CLI fit that mold. Useful, but bounded — the assistant stayed in your editor.

What changed in the past year is the missing half of the loop. An assistant that writes code for an agent but cannot deploy that agent forces you to context-switch into Docker, IAM, Cloud Run, secrets management, and a half-dozen other concerns. The cognitive overhead kills adoption.

Google collapsed those steps. Gemini CLI doesn’t just help you author an ADK agent — it can scaffold the project, write the tools, define the orchestration, and hand it off to Agent Engine through a single deploy command. MCP support means the same CLI can pull in production context (Firestore, BigQuery, your internal APIs) at author time. A2A means the agent you just deployed can find and call other agents without you hand-coding discovery logic.

The shift is from “assistant that helps you write code” to “assistant that operates a deployment pipeline through conversation.” That’s what the title is pointing at — not a single product release but the moment a CLI started behaving like an agent platform’s front door.

How It Works

The mental model has three layers stacked on top of each other.

Layer 1 — Authoring. Inside Gemini CLI, you describe what you want in natural language. The CLI uses its built-in tools (file ops, shell, web fetch, Google Search) plus any MCP servers you’ve attached to scaffold a project. For ADK agents, it writes the directory structure (agent.py, tools/, requirements.txt, deploy_config.yaml) and the orchestration code — typically a SequentialAgent or ParallelAgent wrapping an LlmAgent with a toolset.

Layer 2 — Definition. ADK treats an agent as a Python object with three properties: a model, a set of tools, and an instruction prompt. The framework manages the event loop, state, and inter-agent handoffs. For multi-agent systems, ADK exposes a parent/sub-agent tree where one orchestrator can dispatch to specialists. The Task API (added in late 2025) gives you structured delegation patterns: single-turn handoff, multi-turn collaboration, and human-in-the-loop gates.

Layer 3 — Deployment and orchestration. Once the agent works locally, the same CLI session pushes it to Vertex AI Agent Engine. Agent Engine handles the production plumbing — HTTPS endpoints, session persistence, scaling, telemetry. If the agent needs to talk to other agents (internal or external), A2A’s Agent Card is registered at deployment and other agents can discover its capabilities via a well-known JSON document. A2A tasks flow as JSON-RPC 2.0 messages; long-running work returns a polling handle and a signed artifact.

The four Google pieces are not the only way to do any one of these layers. What they are is the only end-to-end pipeline I’ve seen that doesn’t make you leave the terminal.

First Look: A Real Example

Here’s what an end-to-end flow actually looks like. I’m walking through a research agent that takes a topic, searches the web, summarizes three sources, and pushes the result to Slack.

Step 1 — Install Gemini CLI.

$ npx @google/gemini-cli
# or, globally:
$ npm install -g @google/gemini-cli
$ gemini --version
gemini 0.9.x

On first run, the CLI walks you through OAuth with a personal Google account and lands you in a REPL with a > prompt.

Step 2 — Scaffold an ADK agent.

> scaffold an ADK agent called "research-bot" that takes a topic,
  searches Google for it, summarizes the top three results, and posts
  the summary to a Slack channel. Use the Slack webhook I'll set as an
  env var.

The CLI uses its built-in tools to create research_bot/agent.py, research_bot/tools/search.py, research_bot/tools/slack.py, and a pyproject.toml. It writes a SequentialAgent with two LlmAgent children — one for search/summarize, one for posting — and wires them through a shared session state.

Step 3 — Test it locally.

$ cd research_bot
$ export SLACK_WEBHOOK_URL=https://hooks.slack.com/services/...
$ adk run .
[user]: quantum error correction
[agent]: Searching... Found 3 sources. Summarizing...
[agent]: Posted to #research-feed.

The adk run command comes from ADK itself and gives you a local REPL against the agent before you ship anything.

Step 4 — Deploy to Vertex AI Agent Engine.

$ gemini deploy research-bot 
    --runtime vertex-agent-engine 
    --region us-central1 
    --a2a enabled

Deploying... Building container... Pushing to Artifact Registry...
Creating Agent Engine resource...
Resource: projects/my-proj/locations/us-central1/reasoningEngines/88231
Endpoint: https://us-central1-aiplatform.googleapis.com/v1/projects/my-proj/
locations/us-central1/reasoningEngines/88231:query
Agent Card: https://us-central1-aiplatform.googleapis.com/v1/
projects/my-proj/locations/us-central1/reasoningEngines/88231/agent-card
Done.

Step 5 — Call it from another agent via A2A.

from a2a_sdk import A2AClient

client = A2AClient("https://us-central1-aiplatform.googleapis.com/...")
task = client.send_task(
    recipient="research-bot",
    payload={"topic": "agentic AI in healthcare"}
)
print(client.wait_for_result(task.id))

Total time from npx to a callable production endpoint: about 15 minutes on my machine, including the Slack webhook setup. None of those individual steps is magical. The fact that they all run from one terminal session is.

Features

Gemini 3 access by default with a 1M-token context window and free tier of 60 requests/minute, 1,000 requests/day against a personal Google account.
Built-in tools for Google Search grounding, file operations, shell commands, and web fetching — no separate SDK needed for the basics.
MCP support out of the box, so any Model Context Protocol server plugs in without glue code.
Multimodal inputs — drop a PDF, a screenshot, or a hand-drawn sketch into the CLI and the agent reasons over it.
Open-source under Apache 2.0 (CLI and ADK both), so security teams can audit the code path and pin to a version.
Code-first ADK — no drag-and-drop builder required; if you know Python you can ship an agent.
Structured agent delegation via ADK’s Task API: single-turn, multi-turn, human-in-the-loop, and task-agents-as-workflow-nodes.
Vendor-neutral A2A protocol with Agent Cards for capability discovery; agents from different frameworks can find and call each other.
Fully managed Agent Engine runtime — serverless scaling, session persistence, context caching, observability, and IAM baked in.
Multi-language ADK surfaces in progress — Python is GA, Go and TypeScript previews are landing in 2026.

Comparison: Gemini CLI vs Claude Code vs OpenAI Agents SDK vs CrewAI

It’s worth being precise about what Google is and isn’t competing with. The CLI competes with Claude Code and Codex CLI. The ADK competes with the OpenAI Agents SDK, the Claude Agents SDK, CrewAI, AutoGen, and LangGraph. Agent Engine competes with hosted runtimes like AWS Bedrock Agents and Azure AI Agent Service. A2A competes with Anthropic’s Model Context Protocol and the emerging ANP standard — but as a complement, not a replacement, for inter-agent communication.

Feature	Gemini CLI + ADK + Agent Engine	Claude Code + Claude Agents SDK	OpenAI Agents SDK + Responses	CrewAI / LangGraph
Terminal agent	Yes (Gemini CLI, Apache 2.0)	Yes (Claude Code, source-available)	Codex CLI, source-available	No native CLI; SDKs only
Agent framework	ADK (Python, Apache 2.0)	Claude Agents SDK (closed beta)	Agents SDK (Apache 2.0)	CrewAI (MIT), LangGraph (MIT)
Managed runtime	Vertex AI Agent Engine (serverless)	Claude.ai + Bedrock via Anthropic SDK	OpenAI hosted / Responses API	Self-hosted (LangGraph Platform is SaaS)
Inter-agent protocol	A2A (Linux Foundation, open standard)	MCP (Anthropic, open standard)	None first-party; community projects	None first-party
MCP support	Yes	Yes (originator)	Yes (third-party servers)	Via community adapters
Model choice	Gemini-first; LiteLLM fallback for others	Claude-only	OpenAI-first; LiteLLM fallback	Model-agnostic out of the box
Free tier	60 req/min, 1,000/day (CLI)	Limited; paid-first	Limited; paid-first	SDK free; runtime paid
SWE-bench Verified (CLI)	~76%	~89%	~85%	N/A (no CLI)
Open-source license	Apache 2.0 (CLI and ADK)	Source-available, not OSI	Apache 2.0 (SDK)	MIT
Best for	End-to-end Google Cloud shops	Autonomous long-running coding tasks	OpenAI model shops	Multi-agent research and orchestration

A few things stand out. Gemini CLI’s free tier is the most generous of the three major CLIs. The combined open-source footprint (CLI + ADK under Apache 2.0) is unusually broad — you can fork and self-host both layers. Claude Code still leads on raw coding-task accuracy, but the gap is narrowing as Gemini 3 rolls out. CrewAI and LangGraph remain the most model-agnostic options; if you want to mix Claude, GPT-5, and Gemini inside one orchestration graph, those frameworks give you more flexibility today.

Limitations and Concerns

This isn’t an unqualified recommendation. Before you wire your production stack to this pipeline, know what’s underneath.

Google lock-in is real. Agent Engine runs on Vertex AI. You cannot easily lift an agent off Vertex and onto AWS or Azure — A2A helps for inter-agent communication but the agent’s runtime, secrets, and observability are bound to Google Cloud. ADK itself is portable, but the “deploy” target is not.
Model choice is narrower than it looks. ADK is technically model-agnostic via LiteLLM, but the documentation, examples, and optimized tool routing are Gemini-first. If you intend to run Claude or GPT inside ADK, you’re working against the grain.
Regional availability is uneven. Agent Engine is GA in a handful of regions (us-central1, us-east5, europe-west4 as of mid-2026). If your data residency requirements point somewhere else, you’ll have a problem.
Billing surprises. Vertex AI Agent Engine charges per query, per session-minute, plus the underlying model tokens. The free Gemini CLI tier does not cover Agent Engine. There is no local “agent engine” — production deployments are billable from request one.
Reliability story is still maturing. The CLI ships weekly previews and has had rough edges during rapid iteration. The Agent Engine SLA is improving but is not at the level of mature Cloud Run or GKE.
A2A adoption is broad but shallow. 150+ organizations backing the protocol is impressive, but most are still at the “supporting” stage — production cross-vendor agent calls are real but not yet routine.
Observability inside Agent Engine is improving but still trails dedicated tooling like LangSmith or Helicone for complex multi-agent traces.

None of these are dealbreakers. They’re the things to budget for when you write the migration plan, not the reasons to skip the evaluation.

Who Should Use This

This stack makes the most sense for three groups.

1. Google Cloud shops that already use Vertex AI. If your data lives in BigQuery, your identity is in Google Workspace, and your ML platform is Vertex, the friction of adopting ADK and Agent Engine is close to zero. You get a managed runtime, IAM you already understand, and a CLI that respects your existing service accounts. This is the obvious starting point.

2. Teams shipping production agents in the next 6–12 months. If you’re past experimentation and need an end-to-end pipeline that handles scaling, state, and observability without you building it, Agent Engine is genuinely the fastest path from laptop to production today. The cost-per-query is reasonable for low-to-mid volume; very high volume still wants custom infrastructure.

3. Multi-agent system builders who care about open standards. If you intend to coordinate agents across vendors — Google, Anthropic, OpenAI, open-source frameworks — A2A is the most credible cross-vendor protocol available, and the Linux Foundation stewardship is a real governance win. Building on A2A now hedges against lock-in at the agent-coordination layer.

If you’re a hobbyist who doesn’t need a managed runtime, the CLI and ADK alone are enough — you can skip Agent Engine and run agents locally. If you need to keep all your infrastructure on AWS or Azure, this stack is the wrong starting point; you’d be using the open-source pieces while paying for the runtime elsewhere.

Final Verdict

Google did not invent any one of these pieces. Coding CLIs existed (Claude Code, Codex). Agent frameworks existed (LangChain, AutoGen, CrewAI). Open protocols existed (MCP, ANP). Managed runtimes existed (Bedrock Agents). What Google did was connect them — terminal to framework, framework to runtime, agent to agent — under a single brand, a single billing relationship, and a single deploy command. That’s the deployment machine the title is referring to, and it’s worth taking seriously.

The catch is the one you’d expect: it’s a Google pipeline, and the deepest layer (Agent Engine) lives on Google Cloud. If you can live with that, what you get is the most direct path from “I want an agent” to “this agent is running in production, talking to other agents” that exists today. The CLI is free, the framework is open-source, and the runtime is mature enough to bet on.

If you can’t live with Google lock-in — or if you need best-in-class coding accuracy above all else — keep Claude Code in your rotation and build on LangGraph or CrewAI for orchestration. But track this stack. The combination of an open-source CLI, an open-source framework, an open standard for inter-agent comms, and a managed runtime under one roof is a meaningful structural move, and competitors will be responding to it through the rest of 2026.

Bottom line: Gemini CLI + ADK + Agent Engine is the most complete Google developer story in years. Try the CLI this afternoon (it’s free). Prototype an ADK agent this week. Push it to Agent Engine when you’re ready for production. Just know what you’re tying yourself to before you sign the bill.