Course Overview: Build AI Agents with Antigravity & Agents CLI

Building Agents with Antigravity and Agents CLI is an advanced-level, instructor-led course designed for software developers and engineers, platform and DevOps engineers, technical and solutions architects, and automation specialists who want to build and manage enterprise-grade AI agents. The course introduces modern agent development workflows using Antigravity, Agents CLI, and the Agent Development Kit (ADK). Participants learn how to move from manual implementation toward high-level orchestration using vibe coding, specification-driven development, architectural prompting, and output verification. Learners explore Antigravity and its desktop and CLI capabilities, Agents CLI lifecycle skills, rapid project scaffolding, ADK project structure, local validation, testing, and evaluation workflows. The course then progresses into managed enterprise agents using the Managed Agents API, including control plane and data plane operations, secure sandbox environments, network allowlists, external data mounts, and deployment strategies. Finally, learners learn how to extend agents with tools, skills, MCP servers, and mounted data, and how to operate agents using asynchronous
interactions, streaming, resilient reconnection patterns, cost telemetry, persistent state, and data security controls.

After completing the AI Agents with Antigravity course, participants will be able to:

  • Utilize Antigravity and the Agents CLI to accelerate enterprise agent development.
  • Explain how ADK and the Agents API simplify the creation of autonomous enterprise agents.
  • Apply the Vibe Coding model to orchestrate agent development.
  • Create formal agent specifications using Gherkin syntax.
  • Evaluate generated agent output against stable specifications.
  • Differentiate between Agent Studio, Managed Agents API, and Antigravity.
  • Use Antigravity Desktop and its Artifacts panel to inspect and manage generated outputs.
  • Operate the Antigravity CLI for agentic coding tasks and terminal commands.
  • Explain how Agents CLI bridges the agent context gap through domain-specific skills.
  • Apply the seven core Agents CLI lifecycle skills.
  • Manage development sessions by explicitly loading relevant skills.
  • Rapidly scaffold ADK agent projects using the Agents CLI.
  • Add deployment targets and package dependencies through command-line scaffolding.
  • Design customized agent workspaces using natural-language intent.
  • Explain the ADK project structure and development lifecycle.
  • Validate and test agents locally using Agents CLI lint and playground.
  • Configure agents with models, instructions, and tools.
  • Execute agent evaluations and analyze execution traces.
  • Create evaluation datasets and metric configurations.
  • Analyze evaluation results and iteratively improve agent behavior.
  • Differentiate between code-first and infrastructure-first deployment strategies.
  • Configure secure managed agent execution environments.
  • Understand control plane and data plane operations
  • Build, run, and harden agents using the Managed Agents API.
  • Differentiate between tools and skills.
  • Explain the architecture and role of Model Context Protocol (MCP).
  • Assemble agents using built-in tools, MCP servers, mounted data, and published skills.
  • Run agents using asynchronous long-running tasks and SSE streaming.
  • Implement fallback polling and reconnection patterns.
  • Analyze execution traces and token telemetry for operational cost management.
  • Manage multi-turn state using interaction and environment scopes.
  • Apply data security boundaries when operating enterprise agents.

Upcoming Batches

Loading Dates...

Key Features of AI Agent Development Skills

  • Vibe Coding and Specification-Driven Agent Development 

  • Antigravity Desktop and CLI 

  • Agents CLI Development Workflow 

  • Rapid ADK Project Scaffolding 

  • ADK Project Structure and Local Testing 

  • Agent Evaluation and Iterative Improvement 

  • Managed Agents API 

  • Control Plane and Data Plane Architecture 

  • Secure Managed Agent Execution 

  • Tools, Skills, and MCP Integration 

  • Resilient Agent Execution and Streaming 

  • State Management, Cost Telemetry, and Data Security

Who should attend this AI Agent Development Certification Training

  • Software Developers and Engineers
  • Platform Engineers
  • DevOps Engineers
  • Technical Architects
  • Solutions Architects
  • Automation Specialists
  • Cloud Professionals
  • AI Application Developers
  • Professionals building enterprise AI agents
  • Professionals responsible for deploying and operating agent applications

Prerequisites for the AI Agent Development Learning course:

• Familiarity with Google Cloud Platform. • Familiarity with software development concepts is recommended. • Understanding of AI agents and application development is beneficial. • Familiarity with the Agent Development Kit is beneficial.

Why choose CloudThat as your training partner?

  • Specialized Google Cloud and Generative AI Expertise 

    CloudThat specializes in Google Cloud, Generative AI, agentic AI, and enterprise cloud technologies, delivering focused learning programs aligned with real-world enterprise use cases.

  •  Industry-Recognized Trainers 

    Our trainers are certified Google Cloud professionals with expertise in Google Cloud, Agent Development Kit, AI agents, enterprise architecture, DevOps, and AI application development. 

  • Hands-On Learning Approach 

    CloudThat emphasizes practical learning through agent development exercises, CLI workflows, project scaffolding, evaluation activities, managed agent deployment, MCP integration, and operational scenarios.

  • Customized Learning Paths 

    Training programs are designed for developers, platform engineers, DevOps professionals, architects, and automation specialists working with enterprise AI agent systems. 

  • Interactive Learning Experience 

    Sessions include demonstrations, guided development activities, command-line workflows, architecture discussions, evaluation exercises, deployment scenarios, and troubleshooting activities. 

  • Continuous Learning and Updates 

    Course content is continuously updated to align with advancements in ADK, Antigravity, Agents CLI, Managed Agents API, MCP, and enterprise agent development practices. 

Learning Objective of Build AI Agents with Antigravity Course

  • This course enables learners to build enterprise agents using Antigravity, Agents CLI, the Agent Development Kit, and the Managed Agents API. Learners will develop the ability to accelerate agent development through vibe coding and specification-driven development, scaffold and validate ADK projects, evaluate agent behavior, and deploy secure managed agents.  Learners will also understand control plane and data plane operations, extend agents using tools, skills, mounted data, and MCP servers, and operate agents using resilient execution patterns, streaming, persistent multi-turn state, cost telemetry, and security controls. 

Course Outline of Building AI Agents with Antigravity Download Course Outline

  • The Vibe Coding model: design intent, delegation, and verification phases
  • The shift from manual implementation to high-level agent development orchestration
  • Spec-driven development and Gherkin syntax
  • Defining correct behaviors, failure states, and edge cases before creating prompts
  • Architectural prompting and output verification
  • Preventing compounding errors during interactive agent development

Demo:

  • Vibe Coding model and output verification

Walkthrough:

  • Specification-driven development with a Gherkin-based agent specification.

  • The Antigravity ecosystem
  • Agent Studio, Managed Agents API, and Antigravity: selecting the right agent-building solution
  • Antigravity 2.0 Desktop and artifact management
  • Running and referencing generated artifacts
  • Antigravity CLI and enterprise setup
  • Maintaining a unified workspace and context across graphical and command-line interfaces

Demo:

  • Antigravity 2.0 Desktop and the Artifacts panel.

Walkthrough:

  • Antigravity CLI and enterprise setup.

  • Bridging the agent context gap
  • How domain-specific skills align coding agent output with the ADK 2.0 surface
  • The seven core lifecycle skills across phases of the agent development loop
  • Context management and version control

Demo:

  • Agents CLI workflow and skill loading.

Walkthrough:

  • The seven core lifecycle skills and a context management scenario

  • Rapid project generation with the agents cli scaffold create command
  • Bypassing interactive configuration dialogs through command-line scaffolding
  • Package management and deployment enhancements
  • Intent-driven scaffolding: translating agent goals into a structured development workspace

Hands-On

  • Agent project scaffolding

Demo:

  • Package and deployment configuration, and intent-driven workspace creation.

  • The end-to-end ADK development lifecycle and project structur
  • Key files and directories generated during scaffolding
  • Core agent configuration: models, instructions, and tools
  • Binding agent components within a standardized application wrapper
  • Local code validation and interactive testing

Demo:

  • agents cli lint and playground testing.

Guided exercise:

  • Agent configuration.

  • Evaluation structure and workflow using the Agents CLI
  • Generating and analyzing execution traces
  • Grading agent performance using LLM-as-judge metrics
  • Evaluation configurations, datasets, and metric definitions
  • Evaluation best practices, common failure modes, and iterative refinement

Demo:

  • Agent evaluation workflow, execution traces, and LLM-as-judge metrics.

Scenario:

  • Analyze evaluation results and refine agent logic.

  • Infrastructure-first vs. code-first approaches
  • Selecting an appropriate deployment foundation for enterprise agent applications
  • The sandbox environment and security boundaries
  • Network allowlists and external data mounts to control agent network and data access
  • Control plane vs. data plane operations: durable agent resources and ephemeral interactions

Demo:

  • Deployment approaches, sandbox environment, and security configuration.

Hands-on Lab:

  • Build, Run, and Harden Agents with Managed Agents API.

  • Tools vs. skills: executable tools and instructional skills
  • Selecting appropriate tools and skills for complex agent tasks
  • Model Context Protocol (MCP) architecture
  • How MCP decouples agent logic from external tool execution
  • Agent assembly on the control plane and skill publication
  • Integrating built-in tools, MCP server connections, mounted data, and published skills

Demo:

  • MCP server connections and agent assembly.

Walkthrough:

  • MCP architecture and skill publication

  • Robust production execution and reconnection patterns
  • Asynchronous long-running tasks and SSE streaming for interactive agent responses
  • Fallback polling mechanisms to handle connection drops
  • The ReAct loop, execution traces, and identifying inefficient reasoning loops
  • Granular token telemetry for operational cost management
  • State management: context persistence across turns, interaction and environment scopes
  • Maintaining strict data security boundaries

Demo:

  • Demo: SSE streaming, fallback polling, and ReAct loop traces.

Walkthrough:

  • Cost telemetry analysis, state management, and a data security scenario.

Select Course date

Loading Dates...
Add to Wishlist

Course ID: 31188

Course Price at

Loading price info...
Enroll Now

FAQs for Building AI Agents with Antigravity

This course is designed for software developers and engineers, platform and DevOps engineers, technical and solutions architects, and automation specialists who want to build and operate enterprise AI agents.

Antigravity is covered as an agent development ecosystem that provides desktop and CLI capabilities for accelerating agentic coding tasks, managing generated artifacts, and maintaining development context.

Agents CLI is a command-line development workflow used to manage agent development activities, skills, scaffolding, validation, testing, evaluation, and other stages of the agent development lifecycle.

Yes. ADK is covered throughout the course, including project structure, agent configuration, local validation, testing, evaluation, and integration with enterprise agent development workflows.

The Managed Agents API provides the managed agent capabilities covered in the course, including durable agent resources on the control plane and agent interactions on the data plane

The control plane is used to define and manage durable agent resources, while the data plane is used to execute ephemeral agent interactions.

Yes. Module 08 covers Model Context Protocol architecture and how MCP can decouple agent logic from external tool execution

Yes. The course includes one lab: Build, Run, and Harden Agents with Managed Agents API.

Yes. Module 06 covers evaluation workflows, execution traces, evaluation datasets, metric configurations, LLM-as-judge metrics, and iterative improvement.

Yes. The course covers sandbox environments, security boundaries, network allowlists, external data mounts, data security boundaries, and operational practices for managed agents.

The course is delivered as a 0.5-day instructor-led training program.

Organizations can accelerate enterprise agent development, standardize agent development workflows, securely deploy managed agents, integrate enterprise tools and data, evaluate agent quality, and operate scalable AI agents using resilient execution and state management practices.

Talk to Us