home / skills / jeremylongshore / claude-code-plugins-plus-skills / adk-deployment-specialist

adk-deployment-specialist skill

safe

/plugins/ai-ml/jeremy-adk-orchestrator/skills/adk-deployment-specialist

This skill deploys and orchestrates Vertex AI ADK agents via A2A, enabling scalable multi-agent workflows with secure sandboxing and memory management.

npx playbooks add skill jeremylongshore/claude-code-plugins-plus-skills --skill adk-deployment-specialist

Review the files below or copy the command above to add this skill to your agents.

Files (7)

SKILL.md

2.5 KB

---
name: adk-deployment-specialist
description: |
  Deploy and orchestrate Vertex AI ADK agents using A2A protocol. Manages AgentCard discovery, task submission, Code Execution Sandbox, and Memory Bank. Use when asked to "deploy ADK agent" or "orchestrate agents". Trigger with phrases like 'deploy', 'infrastructure', or 'CI/CD'.
allowed-tools: Read, Write, Edit, Grep, Glob, Bash(cmd:*)
version: 1.0.0
author: Jeremy Longshore <[email protected]>
license: MIT
---

# Adk Deployment Specialist

## Overview

Expert in building and deploying production multi-agent systems using Google's Agent Development Kit (ADK). Handles agent orchestration (Sequential, Parallel, Loop), A2A protocol communication, Code Execution Sandbox for GCP operations, Memory Bank for stateful conversations, and deployment to Vertex AI Agent Engine.

## Prerequisites

- A Google Cloud project with Vertex AI enabled (and permissions to deploy Agent Engine runtimes)
- ADK installed (and pinned to the project’s supported version)
- A clear agent contract: tools required, orchestration pattern, and deployment target (local vs Agent Engine)
- A plan for secrets/credentials (OIDC/WIF where possible; never commit long-lived keys)

## Instructions

1. Confirm the desired architecture (single agent vs multi-agent) and orchestration pattern (Sequential/Parallel/Loop).
2. Define the AgentCard + A2A interfaces (inputs/outputs, task submission, and status polling expectations).
3. Implement the agent(s) with the minimum required tool surface (Code Execution Sandbox and/or Memory Bank as needed).
4. Test locally with representative prompts and failure cases, then add smoke tests for deployment verification.
5. Deploy to Vertex AI Agent Engine and validate the generated endpoints (`/.well-known/agent-card`, task send/status APIs).
6. Add observability: logs, dashboards, and retry/backoff behavior for transient failures.

## Output

- Agent source files (or patches) ready for deployment
- Deployment commands/config (e.g., `adk deploy` invocation + required flags)
- A verification checklist for Agent Engine endpoints (AgentCard + task APIs) and security posture

## Error Handling

See `{baseDir}/references/errors.md` for comprehensive error handling.

## Examples

See `{baseDir}/references/examples.md` for detailed examples.

## Resources

- ADK docs: https://cloud.google.com/vertex-ai/docs/agent-engine
- Workload Identity (CI/CD): https://cloud.google.com/iam/docs/workload-identity-federation
- A2A / AgentCard patterns: see `000-docs/6767-a-SPEC-DR-STND-claude-code-plugins-standard.md`

Overview

This skill deploys and orchestrates Vertex AI ADK agents using the A2A protocol and AgentCard discovery. It packages agent code, configures Code Execution Sandbox and Memory Bank integrations, and pushes validated runtimes to Vertex AI Agent Engine for production use. Use it to automate multi-agent workflows and to standardize CI/CD deployment for ADK-based agents.

How this skill works

The skill inspects agent contracts, generates AgentCard metadata, and wires A2A interfaces for task submission and status polling. It prepares minimal tool surfaces (Code Execution Sandbox, Memory Bank) required by each agent, runs local smoke tests, and executes deployment commands targeting Vertex AI Agent Engine. Post-deploy checks verify /.well-known/agent-card and task APIs, and observability hooks are added for logs and retries.

When to use it

You need to deploy a single agent or multi-agent system to Vertex AI Agent Engine.
You want to orchestrate agents in Sequential, Parallel, or Loop patterns using A2A.
You are integrating a Code Execution Sandbox or Memory Bank for stateful agents.
You are building CI/CD pipelines for ADK agent deployments with Workload Identity.
You need production verification of AgentCard discovery and task APIs.

Best practices

Define a clear agent contract: inputs, outputs, required tools, and orchestration pattern before coding.
Prefer short-lived credentials (OIDC/WIF) and avoid committing long-lived keys in repo.
Start with minimal tool surfaces and iterate: add Sandbox/Memory only when required.
Run local smoke tests including failure and retry scenarios before pushing to Agent Engine.
Add observability (structured logs, dashboards) and exponential backoff for transient errors.

Example use cases

Deploy a trio of agents where one ingests data, one enriches it, and one generates final outputs with sequential orchestration.
Orchestrate parallel agents to run independent analysis tasks, then aggregate results via a coordinator agent.
Set up a looped agent to perform periodic monitoring and stateful actions using Memory Bank.
Integrate Code Execution Sandbox to allow controlled GCP operations during task execution.
Automate ADK agent deployment in CI/CD using Workload Identity for secure artifact publishing.

FAQ

What prerequisites are required?

A Google Cloud project with Vertex AI enabled, ADK installed and pinned to a supported version, and a plan for credentials and secrets.

How do I verify the deployment?

Check /.well-known/agent-card, call task send/status APIs, and run the included smoke tests to validate behavior and observability.