AgentKit 2.0 has arrived, and it's a watershed moment for AI-assisted development. Google's open-source Agent Development Kit (ADK) now ships 16 specialized agents and 40+ domain-specific Agent Skills, deeply integrated into Antigravity. This guide walks you from zero to fluent in multi-agent development.
What Is AgentKit 2.0?
AgentKit 2.0 is Google Labs' open-source framework for building AI agents that compose, reason, and execute autonomously. Antigravity packages it with production-grade tooling.
Key properties:
- Model-agnostic: Works with Gemini, Claude, GPT, or any LLM via standard adapters
- Deployment-agnostic: Run locally, on Cloudflare Workers, Google Cloud Run, or AWS Lambda
- Agent Skills: Pre-built, composable actions for auth, databases, deployment, monitoring, and more
- Deep Gemini integration: In Antigravity, Agent Skills are optimized for Gemini 3.1 Pro's reasoning capabilities
Think of it as UNIX philosophy for AI: small, focused agents that do one thing well, combined into powerful workflows.
The 16 Specialized Agents
AgentKit 2.0 ships with a curated suite of agents, each an expert in its domain:
- Orchestrator Agent: Breaks down high-level goals into subtasks, delegates to specialists
- Spec Agent: Converts requirements into formal specifications (OpenAPI, JSON Schema)
- Frontend Agent: React, Vue, Svelte, or vanilla JS component implementation
- Backend Agent: REST API design, ORM integration, business logic
- Database Agent: Schema design, migration generation, query optimization
- Infrastructure Agent: Docker, Kubernetes, IaC (Terraform, CloudFormation)
- Auth Agent: OAuth, JWT, OIDC, SAML implementation
- Testing Agent: Unit, integration, and E2E test generation with coverage analysis
- Security Agent: Vulnerability scanning, authorization checks, data protection audits
- Performance Agent: Memory profiling, caching strategies, CDN configuration
- DevOps Agent: CI/CD pipeline setup, log aggregation, alerting
- Documentation Agent: API docs, user guides, code comments (auto-generated)
- Integration Agent: Third-party API orchestration, webhooks, data sync
- Analytics Agent: Metrics collection, dashboard design, user behavior analysis
- Migration Agent: Legacy system assessment, phased modernization planning
- QA Agent: Test case generation, flaky test detection, regression analysis
40+ Agent Skills: The Tactical Toolkit
If agents are strategists, Agent Skills are their hands. A skill is a discrete, composable action that an agent can execute. Think of it as a function call with structured input/output.
Authentication Skills:
- Google Sign-In flow orchestration
- GitHub OAuth with state validation
- JWT encode/decode with key rotation
- Session invalidation on logout
Database Skills:
- PostgreSQL schema scaffolding
- MongoDB schema design consultation
- Migration script generation
- Index creation recommendations based on query patterns
Real-Time Skills:
- WebSocket connection pooling
- Server-Sent Events setup
- CRDT-based conflict resolution
- Optimistic update rollback logic
Deployment Skills:
- Vercel deployment with branch aliases
- Google Cloud Run containerization
- Cloudflare Workers deployment and edge caching
- Environment variable injection and rotation
Monitoring Skills:
- Google Cloud Logging setup
- Datadog metric forwarding
- Custom alert rule definition
- Incident escalation workflows
Each skill has:
- Input schema: TypeScript interface defining required parameters
- Output schema: Structured response format
- Error handling: Graceful failure modes with retry logic
- Documentation: Auto-generated via Spec Agent
Building Custom Agent Skills in Antigravity
Let's walk through creating a new Agent Skill from scratch.
Phase 1: Specification
Open Antigravity's Spec Agent and describe your skill:
"I need an Agent Skill called 'send-email-campaign' that:
- Accepts a template ID, recipient list, and send time
- Validates recipient email addresses
- Tracks delivery status
- Reports bounce rates and open rates"
Spec Agent outputs:
- OpenAPI specification (YAML)
- TypeScript interfaces
- Error codes and retry strategies
- Unit test skeleton
Phase 2: Implementation
The Backend Agent generates boilerplate that conforms to ADK's Skill interface:
interface Skill {
name: string;
description: string;
execute(input: SkillInput): Promise<SkillOutput>;
parameters: ParameterSchema;
}You fill in the business logic. Testing Agent automatically creates test cases.
Phase 3: Integration Testing
Create a minimal workflow that uses your new skill:
Orchestrator → EmailCampaign Agent → your-new-skill
Antigravity's testing harness runs this in isolation. If it passes, merge to the shared skill registry.
Phase 4: Reuse Across Workflows
Once tested, your skill is available to any agent, any workflow, any project within your org. Versioning is handled automatically.
Multi-Agent Orchestration Patterns
Three core patterns for composing agents:
Sequential (Pipeline)
Spec Agent → Backend Agent → Testing Agent → DevOps Agent
Output of one feeds input to the next. Use when there's strict dependency ordering (e.g., schema design before API implementation).
Pros: Predictable, easy to debug Cons: Slower (agents wait for predecessors)
Parallel (Fan-Out)
├─ Frontend Agent
├─ Backend Agent
Orchestrator ┤
├─ Database Agent
└─ Infrastructure Agent
Independent components built simultaneously. Use for greenfield projects where teams can work in isolation.
Pros: Fast (all agents work at once) Cons: Risk of misalignment between agents
Hierarchical (Tree)
Top Orchestrator
├─ Spec Sub-Orchestrator (requirements → design docs)
├─ Implementation Sub-Orchestrator (dev → code review)
└─ Testing Sub-Orchestrator (QA → deployment readiness)
Useful for massive projects (thousands of LOC) where sub-teams own agent clusters.
Pros: Scales to large orgs Cons: Extra complexity managing inter-tree communication
Antigravity's Manager View provides visual drag-and-drop composition of all three patterns.
Real-World Example: Building a Full-Stack SaaS in 25 Minutes
Let's trace a realistic workflow: "Build a collaborative notes app with Google OAuth, real-time sync, Stripe billing, and performance monitoring."
Target:
- React frontend (dark mode, responsive)
- Node.js/Express backend (REST + WebSocket)
- PostgreSQL database (multi-user support)
- Google Cloud Run deployment
- Stripe payment integration
- Full test coverage
Agent execution timeline:
-
Spec Agent (2 min): Parse requirements
- Output: OpenAPI spec, database schema diagram, user stories
-
Database Agent (4 min, parallel start): PostgreSQL schema
- users, notes, shares, audit_logs tables
- Indexes on frequently filtered columns
- Row-level security policies
-
Backend Agent (6 min): Express.js REST API
- /notes CRUD endpoints
- /auth/login (Google OAuth callback)
- /shares (collaborative access control)
- /billing (Stripe webhook handler)
-
Frontend Agent (5 min): React components
- Editor (rich text with CRDT for real-time sync)
- SidebarNav (note list, share settings)
- AuthFlow (Google Sign-In button, token storage)
- StripeCheckout modal
-
Auth Agent (3 min): OAuth + JWT
- Google OAuth flow with PKCE
- JWT refresh token rotation
- Session-based rate limiting
-
Real-Time Agent (2 min): WebSocket sync
- CRDT conflict-free merges
- Optimistic updates with rollback
- Presence tracking (who's editing)
-
Testing Agent (5 min): Test suite generation
- Jest: auth flows, API validation, CRDT correctness
- Playwright: editor interactions, real-time sync
- Performance benchmarks (render time <16ms)
-
Security Agent (3 min): Vulnerability scan
- OWASP Top 10 checks
- Dependency audit (npm audit)
- Data exposure risk review
-
Infrastructure Agent (4 min): Cloud Run + GitHub Actions
- Dockerfile with multi-stage build
- .github/workflows/deploy.yml
- Environment variable injection (DB_URL, STRIPE_KEY)
-
Documentation Agent (2 min): API docs
- Swagger UI auto-generated from OpenAPI spec
- README with architecture diagrams
- CONTRIBUTING.md for team onboarding
Total elapsed time: ~25 minutes Equivalent manual effort: 3–5 days
Referencing the AGI Era: Giovanni Galloro's ADK Tutorial
For advanced Agent Skills patterns, the community references Giovanni Galloro's comprehensive ADK series published by Google. Key takeaways:
- Input validation: Use TypeScript strict mode to enforce type safety at the boundary
- Async handling: For long-running skills (training models, batch processing), return a job ID and let the Orchestrator poll for completion
- Error recovery: Define retry budgets (e.g., "try up to 3 times, exponential backoff")
- Observability: Emit structured logs so the Manager View can surface bottlenecks
His work is foundational for anyone building production-grade Agent Skills.
Spec-Driven Development (SDD)
Antigravity encourages a spec-first workflow, sometimes called Spec-Driven Development:
- Write high-level requirements (plain English)
- Spec Agent converts to formal spec (OpenAPI, schema, error codes)
- Agents implement against spec (guaranteed alignment)
- Tests auto-generated from spec (spec becomes the source of truth)
- Spec evolves with feedback (versioned, backward-compatible)
Unlike waterfall ("write spec once, code forever"), SDD treats specs as living documents. Each agent references the latest spec version.
Manager View: Monitoring Multi-Agent Execution
Antigravity's Manager View is the control center for multi-agent workflows. You see:
- Task Tree: Hierarchical breakdown (which agent doing what)
- Execution Timeline: Start/end times for each agent (visualize parallelization)
- Dependency Graph: Which agents block which (calculate critical path)
- Output Preview: Live preview of agent outputs (before integration)
- Error Log: Failed agents, root causes, suggested mitigations
- Resource Metrics: Token usage, compute time, cost tracking
You can pause an agent mid-execution, inject instructions ("use Tailwind CSS, not Bootstrap"), or manually override an agent's output.
Portability: Agent Skills Across Tools
Because Agent Skills follow open standards (OpenAPI + JSON Schema), they work beyond Antigravity:
- Gemini CLI:
adk skill call send-email --input '{"template":"welcome","email":"user@example.com"}' - Cursor: Reference Agent Skills in code comments; Cursor proposes implementations
- Claude Code: Use Agent Skills as external functions in prompts
- Future frameworks: Any system implementing ADK spec can compose your skills
This portability means Agent Skills become organizational IP—once written, useful everywhere.
Multi-Agent Development: Best Practices Checklist
- Start small: one agent + one skill, not ten agents + ten skills
- Specification first: always let Spec Agent vet your requirements
- Test coverage: target >80% coverage on Agent Skills
- Error handling: define fallback behavior explicitly (don't assume happy path)
- Observability: enable structured logging, check Manager View regularly
- Versioning: Agent Skills should be semver-compatible
- Documentation: let Documentation Agent write it; human review once
What's Next?
Learning AgentKit 2.0 isn't about mastering a tool—it's about internalizing a new development paradigm. The trajectory looks like:
Week 1: Understand the 16 built-in agents (what they do, when to use them) Week 2: Create your first custom Agent Skill (email, payment, data sync) Week 3: Build a workflow with 5+ agents (orchestrate in series + parallel) Month 2: Contribute domain-specific skills to your org's shared registry Ongoing: Become the architect who designs agent workflows, not the coder who writes lines
This shift—from "I write code" to "I compose agents"—is where software development is headed.
Welcome to the future.