google-cloud-solution-build-deploy-agents

Files (8)

• SKILL.md
• implementation-template.md · assets/
• solution-template.md · assets/
• validation-template.md · assets/
• attribution.md · references/
• design-principles.md · references/
• product-mappings.md · references/
• related-guidance.md · references/

SKILL.md (first lines)

# Build and deploy AI agents on Google Cloud

This skill guides agents through the workflow of designing and implementing a
tailored multi-product solution in the cloud for a given workload, use case, or
requirement.

## Attribution

**MUST READ**: Before executing any `gcloud`, REST API, or MCP command, you
MUST read and follow the instructions in
[Usage Attribution](references/attribution.md).

## Workflow

The solution design and implementation workflow is divided into the following
phases:

*   **Phase 1: Requirements discovery and analysis**: Analyze the workload's
    requirements, constraints, dependencies, and current state.
*   **Phase 2: Solution design**: Build a technology stack, architecture, and
    deployment configuration for the workload based on Google Cloud design best
    practices and recommendations.
*   **Phase 3: Implementation plan**: Generate automation and instructions to
    deploy the solution.
*   **Phase 4: Solution validation**: Validate that the deployment meets the
    requirements of the workload.

Copy this checklist into your active task/plan artifact to track progress across
the four phases:

-   [ ] Phase 1: Requirements discovery and analysis completed & confirmed.
-   [ ] Phase 2: Solution architecture generated & approved.
-   [ ] Phase 3: Implementation plan generated & approved.
-   [ ] Phase 4: Solution validation generated & approved.

### Phase 1: Requirements discovery and analysis

1.  **Discover requirements**: Gather and understand the functional and
    non-functional requirements, business goals, and current state (if any) of
    the workload, including its architecture, dependencies, and constraints.

    *Important*: First, check whether the user's initial prompt has already
    answered the following questions or whether the prompt explicitly asks you
    to propose a solution architecture/diagram from a given set of parameters.

    -   If the user's prompt provides sufficient requirements and it explicitly
        requests an architecture proposal or diagram, then skip asking the
        questions below, and instead proceed to the step **Recommend agent
        design pattern**.
    -   If the user's prompt doesn't provide sufficient requirements, then
        complete these steps to gather missing information:

        1.  Ask the user to describe the functional requirements of their
            workload: business processes, activities, and use cases.

        2.  Ask the user to describe the non-functional requirements (security,
            privacy, compliance, reliability, disaster recovery, cost,
            operations, performance, and sustainability) of their workloads.

        3.  Ask the user what existing systems, knowledge bases, product
            documentation, or other documentation the AI agents need to access
            for grounded guidance.

        4.  Ask the user to describe dependencies, if any, on other workloads,
            products, or tools.

        5.  Review the input that the user has provided so far, and check
            whether there are any ambiguities or contradictions in the input.

            If you identify any ambiguities or contradictions in the
            requirements that the user has provided, then do the following for
            each ambiguity or contradiction that you identify:

            *   Describe the ambiguity or contradiction.
            *   Ask the user how they wish to resolve the ambiguity or
                contradiction.
                *   If the user delegates the choice to you (e.g., the user
                    replies with "do what you think is best" or "you decide"),
                    then provide a clear suggestion to resolve the ambiguity or
                    contradiction, explain your reasoning, and ask the user to
                    approve your suggestion.

            **Critical**: Until all the ambiguities and contradictions that you
            identify are resolved according to the preceding guidance, you must
            NOT recommend or generate any architecture design, technical
            decomposition, or Google Cloud product recommendations.

2.  **Recommend agent design pattern**: Evaluate the complexity, workflow,
    latency, and cost requirements of the workload to recommend an agent design
    pattern:

    -   **Single-agent system**: Recommend for simpler tasks, acting as an
        effective starting point to refine core logic and tools.
    -   **Multi-agent system**: Recommend for complex problems requiring
        multiple specialized agents to collaborate on a workflow.

3.  **Identify components**: Based on the requirements analysis, generate a
    technical decomposition of the workload. The technical decomposition must
    identify the logical components of the workloads and their relationships.
    Also identify any cross-cloud components, hybrid components, or on-premises
    components that the solution needs to integrate with.

4.  **Ask for confirmation**: Ask the user to confirm whether the recommended
    design pattern and technical decomposition match their workload
    requirements.

5.  **Iterate**: If the user requests changes, generate an updated technical
    decomposition, and ask the user to confirm the changes. Continue iterating
    until the user confirms the technical decomposition. Proceed to the next
    phase only after the user provides confirmation of the technical
    decomposition.

### Phase 2: Solution design

1.  **Retrieve relevant Google Cloud guidance from
    `references/related-guidance.md`**.

    *Important*: Use the content that you retrieved from
    `references/related-guidance.md` to ground the guidance that you generate in

From google/skills, Apache-2.0.

More from google/skills