How to use the new Agents CLI to bridge the gap between AI POCs and production-ready systems on Google Cloud.

The Problem

As a Cloud GDE, I was recently granted early access to an unreleased Google tool to test before its official launch. I decided to spend a couple of hours this Sunday having some fun putting it through its paces, specifically looking at how it handles the most painful bottleneck in AI engineering today: graduating from a prototype to production.

If you've been working with agentic AI recently, you already know the story. Building a simple standalone Python script that calls an LLM is easy. But what happens when you need to take that Proof of Concept (POC) into a production environment?

Suddenly, you are wrestling with Terraform scripts, spinning up CI/CD pipelines, configuring Secret Management, and writing evaluation harnesses so you don't push hallucinating agents into production. You end up spending more time writing boilerplate infrastructure than focusing on the actual solution design.

To solve this, Google presents Agents CLI.

What is the Agents CLI?

The Agents CLI is the definitive, machine-readable programmatic interface for the Agent Development Lifecycle (ADLC). Think of it as a unified "assembly line" for building, evaluating, and deploying AI agents to the full Google Cloud Agent Platform (Vertex AI, Cloud Run, etc.).

More importantly, it is built to empower both Human developers and AI Coding Agents. Whether you are using Gemini CLI, Cursor, or Antigravity, the Agents CLI provides your AI assistant with a direct, predictable interface to the entire cloud platform.

My Test Drive: The Finance Agent

To really see how the CLI performs under pressure, I started to build a simple finance-agent, designed to assess user risk tolerance and fetch mock stock data. I wanted to test the balance between developer control and AI autonomy.

For the test, I split my workflow 50/50:

1. Human Mode: Half the time, I acted as the architect, directly running deterministic commands in my console in a declarative way (e.g., executing agents-cli init or agents-cli test).
2. AI Autonomy: The other half, I relied entirely on the specific skills provided in Antigravity, letting the AI coding agent invoke the CLI programmatically to write the internal logic and run local servers.

This hybrid approach felt like a superpower. You can lean on the AI to generate the heavy lifting, but the CLI gives you the deterministic "Human Mode" execution whenever you need to step in and tighten the pipeline.

Core Benefits & Features

1. Zero-to-One Boilerplate (init & enhance)

With a traditional build, setting up an Agent Development Kit (ADK) repository takes hours. With the Agents CLI, it is instantaneous. By running the init command, you generate a fully formed repository structure.

# Scaffold the standard ADK template using automatic defaults
$ agents-cli init finance-agent -y --agent adk --deployment-target cloud_run

This generates a clean, scalable architecture ready for development:

finance-agent/
├── app/               # Core agent code (agent.py, fast_api_app.py)
├── tests/             # Unit and integration tests
├── GEMINI.md          # AI-assisted development context
└── pyproject.toml     # Dependencies managed strictly by uv

However, a raw application is not production-ready. Once your base logic is scaffolded, you can run agents-cli enhance to bolt on deployment configurations and CI/CD pipelines without rewriting the core application.

$ agents-cli enhance

This immediately injects the necessary enterprise structures into your project:

finance-agent/
├── .cloudbuild/       # CI/CD pipeline configurations for Cloud Build
├── deployment/        # Terraform infrastructure scripts

2. The Evaluation Harness (eval & compare)

You cannot run AI in production without strict quality control. The Agents CLI comes with a built-in evaluation methodology using LLM-as-a-judge and trajectory scoring.

You simply populate your tests/eval/evalsets/ folder with specific scenarios and ground-truth datasets (e.g., verifying the 50/30/20 budgeting rule or emergency fund logic), and run the pipeline:

$ agents-cli eval --evalset tests/eval/evalsets/finance.evalset.json

Eval Run Summary
finance_eval:
  Tests passed: 5
  Tests failed: 0

This ensures a data-driven approach by tracking the exact regressions and improvements between runs, completely avoiding the "it works on my machine" problem when interacting with non-deterministic LLMs.

3. Deployments & Infrastructure (infra prod & deploy)

Instead of writing custom YAML for Google Cloud Build from scratch or fighting with manual IAM permissions, you simply tweak the Terraform configuration files generated earlier by agents-cli enhance, and then apply them directly to Google Cloud:

# Provision analytical BigQuery datasets, artifact registries, and service accounts
$ agents-cli infra prod

# Containerize the codebase and push to a live Cloud Run service
$ agents-cli deploy

These two commands seamlessly handle Dev/Prod environment separation, Secret Management, and service endpoints, pushing your local codebase securely to Cloud Run or the Agent Engine without the headache.

Integration via Skills: Arming Your Coding AI

Before we wrap up, it's crucial to understand how deeply this integrates with modern AI development environments. Google also developed these skills I had the chance to test during this early preview, intentionally built to inject specific technical context natively into IDEs like Cursor, Gemini CLI, and Antigravity.

Instead of searching the web for missing agent-cli documentation (or worse, hallucinating unsupported Python code), your coding agent gains exact contextual awareness directly through these bundled skills:

• /agents-cli-workflow: Provides the agent with the definitive development lifecycle, code preservation rules, and model selection.
• /agents-cli-adk-code: The master Python API reference containing exactly how to write tools, orchestration, state, and callbacks within the environment.
• /agents-cli-scaffold: Teaches the AI how to use the CLI to scaffold a project (init).
• /agents-cli-eval: Injects evaluation methodology (metrics, evalsets, LLM-as-judge).
• /agents-cli-deploy: Gives the AI instructions on CI/CD rules, secrets management, and pushing to Cloud Run via the CLI.
• /agents-cli-publish: How to register the finalized agent to Gemini Enterprise.
• /agents-cli-observability: Guides the AI to set up Cloud Trace, BigQuery exports, and Cloud Logging integrations natively.

Real-World Gotchas & Teardown

As smooth as the workflow is, it's still cloud engineering. During my test drive, I hit a classic GCP security hurdle:

• The 403 Forbidden Error: Immediately post-deployment, my endpoint returned a 403 error. This isn't a bug; Cloud Run secures endpoints against unauthenticated access by default. I had to manually apply a gcloud IAM policy binding (roles/run.invoker to allUsers) to expose the agent's endpoint properly.

• Full Teardown (terraform destroy): When you are done experimenting, don't leave your bill running. Because agents-cli organizes infrastructure cleanly under deployment/, I was able to completely deprovision my active Cloud footprint (BigQuery, Storage, Service Accounts) by executing a standard terraform destroy. (Note: you will still need to manually delete your generated GitHub repository!).

Conclusion

The new Agents CLI completely redefines the "zero-to-one" experience for AI data products. It strips away the friction of setting up infrastructure, enforces standard data engineering practices, and bridges the gap between unreliable proof-of-concepts and enterprise-grade systems.

Whether you are using the CLI manually in your terminal or letting Antigravity drive it dynamically, it ensures your code is clean, evaluated, and ready for production before it even leaves your local machine.