Catalog
fauziyasin-s2m4qw/google-antigravity-sdk

fauziyasin-s2m4qw

google-antigravity-sdk

Design, implement, and debug autonomous AI agents and multi-agent systems using the Google Antigravity (AGY) SDK. ACTIVATE this skill when the user wants to create, configure, or orchestrate Google Antigravity agents.

v1.0LATEST
NewUpdated Jul 28, 2026

Google Antigravity SDK

Installation & Setup

Before proceeding with any Google Antigravity tasks, ensure the environment is ready:

  • Verify Applicability: If operating in an existing codebase, verify that using this Python SDK is possible and appropriate for the project.
  • Check Dependencies: Check if google-antigravity is listed in the project's dependencies (e.g., requirements.txt, pyproject.toml).
  • Install Package: Ensure the google-antigravity Python package is installed.
  • Authentication Setup: Check for a valid GEMINI_API_KEY environment variable or a .env file (required to access Gemini models).
    • If credentials are missing, you MUST actively help the user get set up with an API key by providing the following link:
      • Default to Google AI Studio: https://aistudio.google.com/app/api-keys
    • Explain that the API key can be passed explicitly in code as shorthand (e.g., LocalAgentConfig(api_key="...")) or automatically read from the environment.
    • For Gemini Enterprise Agent Platform (formerly Vertex AI) authentication, the SDK uses Application Default Credentials (ADC). Instruct the user to run gcloud auth application-default login and configure the agent with vertex=True along with project and location in LocalAgentConfig.

Routing Table

Use the following information to dig deeper into specific topics based on the user request. Read the referenced files or explore the directories to find relevant information.

References

  • If the user needs to understand the high-level overview and core concepts of the Google Antigravity SDK (Agent, Conversation, Connection), read references/architecture.md.
  • If the user needs to perform advanced agent configuration, select appropriate models, or understand the critical rules for model identifiers to avoid assumptions, read references/agent_configuration.md.
  • If the user needs to extend an agent's capabilities by integrating Model Context Protocol (MCP) servers, or configure tool permissions for the agent, read references/mcp_integration.md.
  • If the user needs to define safety policies, resolve execution order, or restrict agent actions using predicates, read references/safety_policies.md.
  • If the user needs to debug failed agents, stream logs, or implement error recovery using hooks to make agents robust, read references/error_handling.md.
  • If the user needs to monitor costs, track token usage (including thinking tokens), or build custom audit logs for advanced monitoring, read references/observability.md.
  • If the user needs to see a list of built-in tools and understand their default state, read references/built_in_tools.md.

Examples

  • If the user needs to implement basic agent behavior, streaming responses, or expose internal thoughts, read examples/getting_started/hello_world.md.
  • If the user needs to equip an agent with custom capabilities (tools) derived from Python functions, or maintain agent state across tool execution, read examples/getting_started/custom_tool.md.
  • If the user needs to shape an agent's persona, define its system instructions, or dynamically adapt its behavior, read examples/getting_started/persona_config.md.
  • If the user needs to build multimodal agents capable of processing images and PDFs, or generating visual content, read examples/getting_started/multimodal.md.
  • If the user needs to implement multi-agent delegation, allowing a main agent to spawn and orchestrate subagents for complex tasks, read examples/getting_started/subagents.md.
  • If the user needs to connect an agent to external services via MCP (Stdio or SSE), read examples/getting_started/mcp_tools.md.
  • If the user needs to create proactive agents that respond to time-based events or file system triggers in the background, read examples/getting_started/periodic_trigger.md.
  • If the user needs to intercept agent lifecycle events (e.g., pre/post turn, tool execution, errors) to customize execution flow, read examples/getting_started/hooks.md.
  • If the user needs to implement turn-level cancellation or programmatic stream aborts, read examples/getting_started/cancellation.md.
  • If the user needs to implement persistent agents that remember past interactions across sessions, read examples/getting_started/persistence.md.
  • If the user needs to override the default application data directory for agent artifacts, scratch files, and media storage, read examples/getting_started/app_data_dir_override.md.
  • If the user needs an agent to output structured data (e.g., JSON matching a Pydantic schema) for reliable integration, read examples/getting_started/structured_output.md.
  • If the user needs to add, configure, or load agent skills into the Google Antigravity SDK agent, read examples/getting_started/agent_skills.md.
  • If the user needs to enable and use built-in web tools (like Google Search or URL fetching) with the agent, read examples/getting_started/web_tools.md. (Note: when fetching massive web pages or articles, pair read_url_content with view_file to inspect cached disk files).
Files7
7 files · 27.3 KB

Select a file to preview

Overall Score

82/100

Grade

B

Good

Grades are signals, not a certification. Always review a skill yourself before use.

Safety

80

Quality

85

Clarity

84

Completeness

75

Summary

The Google Antigravity SDK skill is a comprehensive instructional guide for designing and deploying autonomous AI agents using Google's Antigravity framework. It provides setup instructions, architectural concepts, configuration patterns, safety policies, and examples for building multi-agent systems. The skill is well-structured with clear routing to reference documentation and practical examples.

Static Analysis Findings

1 finding

Patterns detected by deterministic static analysis before AI scoring. Hover over any finding code for detailed information and remediation guidance.

Credential Exposure
SEC-020Direct .env File Access

Direct .env file access

SKILL.md.env

Detected Capabilities

read reference documentationconfigure agent authentication via API keysmanage environment variables (GEMINI_API_KEY)define custom tool implementationsenable/disable built-in tools (file operations, shell execution, web access)configure safety policies and access controlsimplement error handling and recovery hooksintegrate external MCP servers (stdio and HTTP transport)stream agent logs and internal thoughts

Trigger Keywords

Phrases that agents use to match this skill to user intent.

build ai agentantigravity sdk setupmulti-agent orchestrationagent safety policiesmcp server integrationcustom agent toolsagent authenticationdebug agent failures

Risk Signals

WARNING

SEC-020: Direct .env file access mentioned in authentication setup instructions

SKILL.md | Authentication Setup section
INFO

Environment variable GEMINI_API_KEY referenced for API authentication

SKILL.md | Authentication Setup section
INFO

run_command tool is denied by default but can be enabled with permissive policies

references/safety_policies.md | Default Behavior section
INFO

policy.allow_all() explicitly enables all tools including shell execution for development only

references/safety_policies.md | Allow All (Development Only) section
WARNING

Custom environment variables can override parent process environment for subprocess execution

references/agent_configuration.md | Custom Environment Variables section

Referenced Domains

External domains referenced in skill content, detected by static analysis.

ai.google.devaistudio.google.comexample.comlocalhost

Use Cases

  • Create and configure autonomous AI agents with the Google Antigravity SDK
  • Implement multi-agent orchestration and delegation patterns
  • Integrate external tools and Model Context Protocol (MCP) servers with agents
  • Define and enforce safety policies for agent tool execution
  • Debug failing agents and implement error recovery mechanisms
  • Monitor token usage and costs for agent deployments
  • Build agents with custom tools, personas, and system instructions

Quality Notes

  • Excellent documentation structure with clear routing table directing users to relevant references based on their task
  • Comprehensive safety policy framework with explicit default behavior (deny run_command), tiered permission levels (allow/deny/ask_user), and production recommendations
  • Multiple levels of documentation: architectural concepts, advanced configuration, error handling, observability, and MCP integration
  • Clear authentication setup guidance with links to official resources (Google AI Studio)
  • Good use of caution/important callouts for safety-critical concepts (e.g., 'Do not assume valid model identifiers')
  • Strong emphasis on security: default-deny approach for shell execution, workspace restrictions, predicate-based argument checking
  • Comprehensive examples directory structure referenced but not all example files included in manifest — incomplete supporting material
  • Well-defined error recovery patterns using hooks for graceful degradation
  • Detailed token usage tracking and cost monitoring guidance
  • Missing explicit scope boundaries for what agents can and cannot do at a system level
Model: claude-haiku-4-5-20251001Analyzed: Jul 28, 2026

Reviews

Add this skill to your library to leave a review.

No reviews yet

Be the first to share your experience.

Use fauziyasin-s2m4qw/google-antigravity-sdk in your dev environment

Command Palette

Search for a command to run...