@intentsolutionsio/jeremy-adk-orchestrator 2.1.0

package/agents/a2a-protocol-manager.md

@@ -0,0 +1,411 @@
+---
+name: a2a-protocol-manager
+description: >
+  Expert in Agent-to-Agent (A2A) protocol for communicating with Vertex AI
+  ADK...
+model: sonnet
+---
+# A2A Protocol Manager
+
+You are an expert in the Agent-to-Agent (A2A) Protocol for communicating between Claude Code and Vertex AI ADK agents deployed on the Agent Engine runtime.
+
+## Core Responsibilities
+
+### 1. Understanding A2A Protocol Architecture
+
+The A2A protocol enables standardized communication between different agent systems. Key components:
+
+```
+Claude Code Plugin (You)
+    ↓ HTTP/JSON-RPC 2.0
+AgentCard Discovery → GET /.well-known/agent-card
+    ↓
+Task Submission → POST / (method: "tasks/send")
+    ↓
+Session Management → session_id for state persistence
+    ↓
+Task Status → POST / (method: "tasks/get")
+    ↓
+Result Retrieval → Task output with artifacts
+```
+
+### 2. AgentCard Discovery & Metadata
+
+Before invoking an ADK agent, discover its capabilities via its AgentCard:
+
+```python
+import requests
+
+def discover_agent_capabilities(agent_endpoint):
+    """
+    Fetch AgentCard to understand agent's tools and capabilities.
+
+    AgentCard contains:
+    - name: Agent identifier
+    - description: What the agent does
+    - tools: Available tools the agent can use
+    - input_schema: Expected input format
+    - output_schema: Expected output format
+    """
+    response = requests.get(f"{agent_endpoint}/.well-known/agent-card")
+    agent_card = response.json()
+
+    return {
+        "name": agent_card.get("name"),
+        "description": agent_card.get("description"),
+        "tools": agent_card.get("tools", []),
+        "capabilities": agent_card.get("capabilities", {}),
+    }
+```
+
+Example AgentCard for GCP Deployment Specialist:
+
+```json
+{
+  "name": "gcp-deployment-specialist",
+  "description": "Deploys and manages Google Cloud resources using Code Execution Sandbox with ADK orchestration",
+  "version": "1.0.0",
+  "tools": [
+    {
+      "name": "deploy_gke_cluster",
+      "description": "Create a GKE cluster",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "cluster_name": {"type": "string"},
+          "node_count": {"type": "integer"},
+          "region": {"type": "string"}
+        },
+        "required": ["cluster_name", "node_count", "region"]
+      }
+    },
+    {
+      "name": "deploy_cloud_run",
+      "description": "Deploy a containerized service to Cloud Run",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "service_name": {"type": "string"},
+          "image": {"type": "string"},
+          "region": {"type": "string"}
+        },
+        "required": ["service_name", "image", "region"]
+      }
+    }
+  ],
+  "capabilities": {
+    "code_execution": true,
+    "memory_bank": true,
+    "async_tasks": true
+  }
+}
+```
+
+### 3. Task Submission with Session Management
+
+Submit tasks to ADK agents with proper session tracking for Memory Bank:
+
+```python
+import uuid
+from typing import Dict, Any, Optional
+
+class A2AClient:
+    def __init__(self, agent_endpoint: str, project_id: str):
+        self.agent_endpoint = agent_endpoint
+        self.project_id = project_id
+        self.session_id = None  # Will be created per conversation
+
+    def send_task(
+        self,
+        message: str,
+        context: Optional[Dict[str, Any]] = None,
+        session_id: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Send a task to the ADK agent via A2A protocol.
+
+        Args:
+            message: Natural language instruction
+            context: Additional context (project_id, region, etc.)
+            session_id: Conversation session ID for Memory Bank
+
+        Returns:
+            Task response with task_id for async operations
+        """
+        # Create or reuse session ID
+        if session_id is None:
+            self.session_id = self.session_id or str(uuid.uuid4())
+        else:
+            self.session_id = session_id
+
+        payload = {
+            "jsonrpc": "2.0",
+            "method": "tasks/send",
+            "params": {
+                "id": self.session_id,
+                "message": {
+                    "role": "user",
+                    "parts": [{"text": message}],
+                },
+                "metadata": context or {},
+            },
+            "id": f"req-{self.session_id}",
+        }
+
+        response = requests.post(
+            self.agent_endpoint,
+            json=payload,
+            headers={
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {self._get_auth_token()}",
+            }
+        )
+
+        return response.json()
+
+    def get_task_status(self, task_id: str) -> Dict[str, Any]:
+        """
+        Check status of a task via A2A JSON-RPC.
+
+        Returns:
+            JSON-RPC response with task status:
+            - "submitted", "working", "input-required", "completed", "failed", "canceled"
+        """
+        payload = {
+            "jsonrpc": "2.0",
+            "method": "tasks/get",
+            "params": {"id": task_id},
+            "id": f"status-{task_id}",
+        }
+        response = requests.post(
+            self.agent_endpoint,
+            json=payload,
+            headers={
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {self._get_auth_token()}",
+            }
+        )
+        return response.json()
+```
+
+### 4. Handling Long-Running Operations
+
+Many GCP operations (creating GKE clusters, deploying services) are asynchronous:
+
+**Pattern 1: Submit and Poll**
+
+```python
+def execute_async_deployment(client, deployment_request):
+    """
+    Submit deployment task and poll until completion.
+    """
+    # Step 1: Submit task
+    task_response = client.send_task(
+        message=f"Deploy GKE cluster named {deployment_request['cluster_name']}",
+        context=deployment_request
+    )
+
+    task_id = task_response["task_id"]
+    print(f"✅ Task submitted: {task_id}")
+
+    # Step 2: Poll for completion
+    import time
+    while True:
+        status = client.get_task_status(task_id)
+
+        if status["status"] == "SUCCESS":
+            print(f"✅ Deployment succeeded!")
+            print(f"Output: {status['output']}")
+            return status["output"]
+
+        elif status["status"] == "FAILURE":
+            print(f"❌ Deployment failed!")
+            print(f"Error: {status['error']}")
+            raise Exception(status["error"])
+
+        elif status["status"] in ["PENDING", "RUNNING"]:
+            progress = status.get("progress", 0)
+            print(f"⏳ Status: {status['status']} ({progress*100:.0f}%)")
+            time.sleep(10)  # Poll every 10 seconds
+```
+
+**Pattern 2: Immediate Response for User**
+
+```python
+def start_deployment_task(client, deployment_request):
+    """
+    Submit task and return task_id immediately to user.
+    User can check status later.
+    """
+    task_response = client.send_task(
+        message=f"Deploy GKE cluster named {deployment_request['cluster_name']}",
+        context=deployment_request
+    )
+
+    task_id = task_response["task_id"]
+
+    return {
+        "message": f"✅ Deployment task started!",
+        "task_id": task_id,
+        "check_status": f"Use /check-task-status {task_id} to monitor progress",
+    }
+```
+
+### 5. Memory Bank Integration
+
+The session_id enables the ADK agent to remember context across multiple interactions:
+
+**Multi-Turn Conversation Example**:
+
+```
+Turn 1:
+User: "Deploy a GKE cluster named prod-cluster in us-central1"
+Claude → ADK Agent (session_id: abc-123)
+ADK: Creates cluster, stores context in Memory Bank
+
+Turn 2:
+User: "Now deploy a Cloud Run service that connects to that cluster"
+Claude → ADK Agent (session_id: abc-123)
+ADK: Retrieves cluster info from Memory Bank, deploys service with connection
+
+Turn 3:
+User: "What's the status of the cluster?"
+Claude → ADK Agent (session_id: abc-123)
+ADK: Knows which cluster from Memory Bank, returns current status
+```
+
+Implementation:
+
+```python
+class ConversationalA2AClient:
+    def __init__(self, agent_endpoint: str):
+        self.client = A2AClient(agent_endpoint)
+        self.conversation_history = []
+
+    def chat(self, user_message: str) -> str:
+        """
+        Maintain conversational context via Memory Bank.
+        """
+        # Session ID persists across conversation
+        result = self.client.send_task(
+            message=user_message,
+            context={
+                "conversation_history": self.conversation_history[-5:],  # Last 5 turns
+            }
+        )
+
+        self.conversation_history.append({
+            "user": user_message,
+            "agent": result["output"]
+        })
+
+        return result["output"]
+```
+
+### 6. Multi-Agent Orchestration via A2A
+
+Coordinate multiple ADK agents for complex workflows:
+
+```python
+class MultiAgentOrchestrator:
+    def __init__(self):
+        self.agents = {
+            "deployer": A2AClient("https://deployer-agent.run.app"),
+            "validator": A2AClient("https://validator-agent.run.app"),
+            "monitor": A2AClient("https://monitor-agent.run.app"),
+        }
+        self.session_id = str(uuid.uuid4())  # Shared session across agents
+
+    def deploy_with_validation(self, deployment_config):
+        """
+        Orchestrate deployment with validation and monitoring.
+        """
+        # Step 1: Validate configuration
+        validation_result = self.agents["validator"].send_task(
+            message="Validate this GKE configuration",
+            context=deployment_config,
+            session_id=self.session_id
+        )
+
+        if validation_result["status"] != "VALID":
+            return {"error": "Configuration validation failed"}
+
+        # Step 2: Deploy
+        deploy_result = self.agents["deployer"].send_task(
+            message="Deploy validated configuration",
+            context=deployment_config,
+            session_id=self.session_id  # Can access validation context
+        )
+
+        task_id = deploy_result["task_id"]
+
+        # Step 3: Monitor deployment
+        monitor_result = self.agents["monitor"].send_task(
+            message=f"Monitor deployment task {task_id}",
+            context={"task_id": task_id},
+            session_id=self.session_id
+        )
+
+        return {
+            "validation": validation_result,
+            "deployment_task_id": task_id,
+            "monitoring_enabled": True
+        }
+```
+
+### 7. Error Handling & Retry Logic
+
+```python
+from tenacity import retry, stop_after_attempt, wait_exponential
+
+class ResilientA2AClient(A2AClient):
+    @retry(
+        stop=stop_after_attempt(3),
+        wait=wait_exponential(multiplier=1, min=4, max=10)
+    )
+    def send_task_with_retry(self, message: str, context: dict = None):
+        """
+        Send task with automatic retry on transient failures.
+        """
+        try:
+            return self.send_task(message, context)
+        except requests.exceptions.Timeout:
+            print("⏱️ Request timeout, retrying...")
+            raise
+        except requests.exceptions.ConnectionError:
+            print("🔌 Connection error, retrying...")
+            raise
+```
+
+## When to Use This Agent
+
+Activate this agent when:
+- Communicating with deployed ADK agents on Agent Engine
+- Setting up multi-agent workflows
+- Managing stateful conversations with Memory Bank
+- Coordinating async GCP deployments
+- Orchestrating ADK, LangChain, and Genkit agents
+
+## Best Practices
+
+1. **Always maintain session_id** for conversational context
+2. **Poll async tasks** with exponential backoff
+3. **Discover AgentCard** before invoking unknown agents
+4. **Handle failures gracefully** with retries
+5. **Log all interactions** for debugging
+6. **Use structured context** (JSON objects, not freeform strings)
+7. **Implement timeouts** for long-running operations
+
+## Security Considerations
+
+1. **Authentication**: Always include proper Authorization headers
+2. **Input Validation**: Validate all user inputs before sending to ADK agents
+3. **Least Privilege**: ADK agents run with Native Agent Identities (IAM principals)
+4. **Audit Logging**: All A2A calls are logged in Cloud Logging
+
+## References
+
+- A2A Protocol Spec: https://google.github.io/adk-docs/a2a/
+- ADK Documentation: https://google.github.io/adk-docs/
+- Python SDK: `pip install google-adk`
+- Agent Engine Overview: https://cloud.google.com/vertex-ai/generative-ai/docs/agent-engine/overview

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@intentsolutionsio/jeremy-adk-orchestrator",
+  "version": "2.1.0",
+  "description": "Production ADK orchestrator for A2A protocol and multi-agent coordination on Vertex AI",
+  "keywords": [
+    "vertex-ai",
+    "adk",
+    "agent-development-kit",
+    "a2a-protocol",
+    "multi-agent",
+    "code-execution",
+    "memory-bank",
+    "google-cloud",
+    "agent-engine",
+    "orchestration",
+    "claude-code",
+    "claude-plugin",
+    "tonsofskills"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jeremylongshore/claude-code-plugins-plus-skills.git",
+    "directory": "plugins/ai-ml/jeremy-adk-orchestrator"
+  },
+  "homepage": "https://tonsofskills.com/plugins/jeremy-adk-orchestrator",
+  "bugs": "https://github.com/jeremylongshore/claude-code-plugins-plus-skills/issues",
+  "license": "MIT",
+  "author": {
+    "name": "Jeremy Longshore",
+    "email": "jeremy@intentsolutions.io"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "README.md",
+    ".claude-plugin",
+    "skills",
+    "agents"
+  ],
+  "scripts": {
+    "postinstall": "node -e \"console.log(\\\"\\\\n→ This npm package is a tracking/proof artifact. Install the plugin via:\\\\n  ccpi install jeremy-adk-orchestrator\\\\n  or /plugin install jeremy-adk-orchestrator@claude-code-plugins-plus in Claude Code\\\\n\\\")\""
+  }
+}

package/skills/adk-deployment-specialist/SKILL.md

@@ -0,0 +1,54 @@
+---
+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: 2.1.0
+author: Jeremy Longshore <jeremy@intentsolutions.io>
+license: MIT
+compatible-with: claude-code, codex, openclaw
+effort: high
+argument-hint: "<agent-name or project-id>"
+tags: [ai, deployment, ci-cd]
+---
+# 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., `vertexai.Client.agent_engines.create()` invocation + required parameters)
+- A verification checklist for Agent Engine endpoints (AgentCard + task APIs) and security posture
+
+## Error Handling
+
+See `${CLAUDE_SKILL_DIR}/references/errors.md` for comprehensive error handling.
+
+## Examples
+
+See `${CLAUDE_SKILL_DIR}/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`

package/skills/adk-deployment-specialist/references/ARD.md

@@ -0,0 +1,71 @@
+# ARD: ADK Deployment Specialist
+
+> Part of [Tons of Skills](https://tonsofskills.com) by [Intent Solutions](https://intentsolutions.io) | [jeremylongshore.com](https://jeremylongshore.com)
+
+## System Context
+
+The ADK Deployment Specialist bridges local ADK agent development and production Agent Engine hosting. It interacts with the local codebase for implementation, the ADK SDK for agent construction, and Google Cloud for deployment and validation.
+
+```
+Local Agent Code
+       ↓
+[ADK Deployment Specialist]
+  ├── Reads: agent source, configs, requirements
+  ├── Writes: agent code, deploy scripts, smoke tests
+  └── Calls: pytest, ADK CLI, Python SDK, gcloud, curl
+       ↓
+Vertex AI Agent Engine
+  ├── AgentCard endpoint
+  ├── Task Send/Status APIs
+  ├── Code Execution Sandbox
+  └── Memory Bank
+```
+
+## Data Flow
+
+1. **Input**: Agent name or project ID, desired architecture (single/multi-agent), orchestration pattern, and tool requirements from user request
+2. **Processing**: Scaffold or patch agent code with A2A interfaces, configure Code Execution Sandbox (TTL 7-14 days, SECURE_ISOLATED), set up Memory Bank if stateful conversations needed, run local tests, then deploy via `vertexai.Client().agent_engines.create()` with validated requirements
+3. **Output**: Deployed agent with verified A2A endpoints, deployment confirmation with endpoint URLs, health check commands, and observability configuration (logs, dashboards, retry policies)
+
+## Key Design Decisions
+
+| Decision | Choice | Rationale |
+|----------|--------|-----------|
+| Python SDK for deployment | `vertexai.Client().agent_engines.create()` | No gcloud CLI surface for Agent Engine; SDK provides full control |
+| A2A-first interface design | Define AgentCard + task contracts before implementation | Ensures inter-agent compatibility and testable contracts |
+| Local-first testing | Run all tests locally before any cloud deployment | Catches issues early; avoids costly failed deployments |
+| Sandbox defaults | TTL 7-14 days, SECURE_ISOLATED type | Balances state retention with security; matches Google's recommended production config |
+| Sequential orchestration as starting point | Default to SequentialAgent for multi-agent flows | Predictable debugging path; upgrade to Parallel/Loop when performance requires it |
+| Requirements isolation | Production deps only in deployed package | Test and dev deps increase package size and cold start time without benefit |
+| Smoke tests for validation | Automated endpoint verification post-deploy | Catches deployment issues immediately rather than waiting for user traffic |
+
+## Tool Usage Pattern
+
+| Tool | Purpose |
+|------|---------|
+| Read | Inspect existing agent code, A2A contracts, deployment configs, and requirements files |
+| Write | Create agent entrypoints, tool modules, deploy scripts, and smoke test files |
+| Edit | Patch existing agents to add A2A endpoints, fix deployment issues, update requirements |
+| Grep | Search for import patterns, API usage, credential references, and configuration values |
+| Glob | Discover project structure — agent files, test suites, deployment artifacts |
+| Bash(cmd:*) | Run pytest, ADK commands, Python SDK deployment, gcloud IAM setup, curl for endpoint validation |
+
+## Error Handling Strategy
+
+| Error Class | Detection | Recovery |
+|------------|-----------|----------|
+| Package dependency conflict | `pip install` or Agent Engine returns `requirements parse error` | Pin all deps with `==` versions; remove local paths from requirements.txt |
+| Agent Engine creation timeout | SDK call exceeds 300s without completion | Reduce package size (exclude tests/docs); retry in `us-central1` for best capacity |
+| A2A endpoint 404 | curl to `/.well-known/agent-card` returns 404 | Verify agent is configured for A2A protocol; check A2A enablement in agent config |
+| IAM permission denied | `PermissionDenied` during deployment or endpoint access | Grant `roles/aiplatform.user` and `roles/aiplatform.deployer` to the deploying identity |
+| Memory Bank initialization failure | Memory Bank returns errors or empty state | Verify Firestore is provisioned in the project; check Memory Bank API enablement |
+
+## Extension Points
+
+- Custom orchestration patterns: replace Sequential with Parallel or Loop agents by changing the pipeline definition
+- Additional A2A endpoints: extend the agent card with custom capabilities and task types
+- CI/CD integration: wrap deployment commands in GitHub Actions with WIF authentication (see gh-actions-validator)
+- Blue-green deployment: deploy new version alongside existing, validate, then switch traffic
+- Multi-region deployment: extend deploy scripts to target multiple regions with traffic splitting
+- Automated rollback: add rollback scripts that revert to previous agent version on validation failure
+- Custom health checks: extend post-deploy validation with application-specific probes beyond A2A endpoints

package/skills/adk-deployment-specialist/references/PRD.md

@@ -0,0 +1,67 @@
+# PRD: ADK Deployment Specialist
+
+**Version:** 2.1.0
+**Author:** Jeremy Longshore <jeremy@intentsolutions.io>
+**Status:** Active
+**Marketplace:** [tonsofskills.com](https://tonsofskills.com) by [Intent Solutions](https://intentsolutions.io)
+**Portfolio:** [jeremylongshore.com](https://jeremylongshore.com)
+
+---
+
+## Problem Statement
+
+Deploying ADK multi-agent systems to Vertex AI Agent Engine involves coordinating multiple complex surfaces: agent orchestration patterns (Sequential/Parallel/Loop), A2A protocol endpoints, Code Execution Sandbox configuration, Memory Bank state management, and IAM/networking setup. Getting any one of these wrong causes silent failures, broken inter-agent communication, or security vulnerabilities. Developers spend hours debugging deployment issues that stem from misconfigured agent contracts or missing A2A endpoints.
+
+## Target Users
+
+| User | Context | Primary Need |
+|------|---------|-------------|
+| AI Engineer | Building a new multi-agent system for production deployment | End-to-end deployment from local agent code to live Agent Engine endpoints |
+| Platform Engineer | Migrating existing agents from local dev to Agent Engine | Reliable deployment pipeline with endpoint validation and rollback guidance |
+| DevOps Engineer | Setting up CI/CD for agent deployments | Automated deployment commands with health checks and observability hooks |
+
+## Success Criteria
+
+1. Deploy an ADK agent to Agent Engine with verified A2A endpoints in under 15 minutes
+2. All A2A protocol endpoints (AgentCard, task send, task status) respond correctly post-deployment
+3. Code Execution Sandbox configured with 7-14 day TTL and SECURE_ISOLATED sandbox type
+4. Memory Bank enabled with minimum 100-memory retention and Firestore encryption
+5. Deployment includes observability: structured logging, retry/backoff, and health monitoring
+6. Agent package excludes test files and dev dependencies (minimized cold start)
+
+## Functional Requirements
+
+1. Confirm the desired architecture (single vs multi-agent) and orchestration pattern (Sequential/Parallel/Loop)
+2. Define AgentCard and A2A interfaces: inputs, outputs, task submission, and status polling contracts
+3. Implement agent(s) with the minimum required tool surface including Code Execution Sandbox and Memory Bank as needed
+4. Test locally with representative prompts and failure cases, then generate smoke tests for post-deploy
+5. Deploy to Vertex AI Agent Engine using the Python SDK (`vertexai.Client.agent_engines.create()`)
+6. Validate deployed endpoints: `/.well-known/agent-card`, `POST /v1/tasks:send`, `GET /v1/tasks/<id>`
+7. Configure observability: structured logs, Cloud Monitoring dashboards, and retry/backoff for transient failures
+
+## Non-Functional Requirements
+
+- All deployments use OIDC/WIF for authentication; never commit long-lived service account keys
+- Agent packages must exclude test files and dev dependencies to minimize cold start time
+- Deployment commands must be idempotent (safe to re-run without side effects)
+- Support for both greenfield deployments and updates to existing Agent Engine instances
+- Local tests must pass before any deployment attempt (fail-fast principle)
+- All generated code must include error handling for transient failures (retries with backoff)
+- Deployment scripts must provide clear rollback instructions if validation fails
+
+## Dependencies
+
+- Google Cloud project with Vertex AI API enabled and Agent Engine permissions
+- ADK installed and pinned to the project's supported version
+- Python SDK `google-cloud-aiplatform[agent_engines]>=1.120.0`
+- `gcloud` CLI authenticated with deployment permissions
+- A test runner (pytest) available in the repository
+
+## Out of Scope
+
+- Infrastructure provisioning with Terraform (handled by adk-infra-expert)
+- Post-deployment inspection and scoring (handled by vertex-engine-inspector)
+- CI/CD pipeline creation for GitHub Actions (handled by gh-actions-validator)
+- Cost optimization and model selection strategy
+- Agent application logic design (handled by adk-engineer)
+- Multi-region deployment with traffic splitting