Google Cloud Solution Agentic AI Bidirectional Streaming

GoogleOfficialPublished by Google

Skill
Workflow
Cloud and DevOps
Apache-2.0
No issues found

From the author

Guides agents to interactively discover customer requirements for live, bidirectional multi-agent AI systems that process continuous streams of multimodal data for real-time technical guidance and safety monitoring. Generates a custom Google Cloud solution that uses opinionated best practices and architecture guidance. Use when users need agentic assistance to design and create a multi-product solution in the cloud for live bidirectional multimodal streaming workloads. Don't use for simple text-based chat applications or workloads without real-time streaming requirements.

— the description by Google

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides a comprehensive, four-phase framework for building real-time, bidirectional AI agent systems that process continuous multimodal data streams. It guides users through requirements discovery, architectural design, implementation planning with Infrastructure as Code (IaC), and validation. The skill ensures solutions are grounded in Google Cloud best practices, focusing on performance, security, and reliability for complex, live-streaming AI workloads.

What it does

Facilitates requirements gathering for multimodal streaming and real-time AI feedback.
Generates technical component decompositions and architecture diagrams in Mermaid format.
Maps workload components to specific Google Cloud products and services.
Provides guidance on security, reliability, and cost optimization for AI agents.
Generates Infrastructure as Code (IaC) and deployment scripts for cloud provisioning.
Defines validation procedures and verification scripts for deployed infrastructure.

When to use it

When designing multi-agent AI systems that require real-time, bidirectional streaming.
When building solutions for live safety monitoring, hazard detection, or visual inspection.
When you need to integrate AI agents with existing knowledge bases or schematic repositories.
When you require an opinionated, best-practice architecture for Google Cloud AI deployments.

Advantages

Ensures architectural consistency by following established Google Cloud design patterns.
Reduces deployment risk through structured validation and dry-run procedures.
Provides clear, step-by-step guidance from initial discovery to final validation.
Promotes operational excellence by integrating logging, tracing, and evaluation tools.

Usage examples

“I need to design a real-time safety monitoring system for a factory floor using video streams and AI agents.”: The agent will initiate the requirements discovery phase, asking about input modalities, specific safety hazards to monitor, and existing infrastructure constraints.
“Help me create an architecture for a bidirectional voice-based AI assistant that needs sub-millisecond latency.”: The agent will guide you through component selection, recommending specific Google Cloud products like Memorystore for Redis to meet your performance requirements.

Install

Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/google/google-cloud-solution-agentic-ai-bidirectional-streaming/download

Unzip it into the cross-client skills folder of your project:

mkdir -p .agents/skills && unzip google-cloud-solution-agentic-ai-bidirectional-streaming.zip -d .agents/skills

Documentation by Google

Live bidirectional multimodal streaming agentic AI solution

This skill guides agents through the workflow to design and implement a tailored multi-product solution in the cloud for a live, bidirectional multimodal streaming 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.

Workflow

The solution design and implementation workflow consists of 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.

Phase 1: Requirements discovery and analysis

[ ] [ ] Step 1: Discover requirements: Understand the functional and non-functional requirements, business goals, and current state (if any) of the workload, including its architecture, dependencies, and constraints. Use the following questions to guide the requirements discovery process:
- What are the primary input modalities (audio, video, or text) and what is the target latency for real-time, narrated feedback?
- Do you require real-time safety monitoring, hazard detection, or visual inspection? If so, then what specific safety hazards, operational risks, or incorrect steps need to be monitored and detected in the video stream?
- What existing systems, knowledge bases, product documentation, or schematic repositories must the AI agents access for grounded guidance?
- What are the client-side device constraints and network limitations?
[ ] [ ] Step 2: Identify components: Based on the requirements analysis, identify the components of the workload and their relationships. Also identify any cross-cloud components, hybrid components, or on-prem components that the solution needs to integrate with.
[ ] [ ] Step 3: Generate component decomposition: Generate a technical decomposition of the components of the workload. The technical decomposition must break down the solution into logical components.
[ ] [ ] Step 4: Ask for confirmation: Ask the user to confirm whether the generated technical decomposition matches their workload requirements.
[ ] [ ] Step 5: Iterate: If the user requests changes, then generate an updated technical decomposition, and ask the user to confirm the changes. Continue iterating until the user confirms the technical decomposition.

Phase 2: Solution design

[ ] [ ] Step 1: Retrieve relevant Google Cloud documentation:
Important: Use the content that you retrieve from Google Cloud documentation to ground the guidance that you generate in the remaining steps of this phase.
[ ] [ ] Step 2: Map components to Google Cloud products: For each component in the confirmed technical decomposition and agentic design pattern, identify the appropriate Google Cloud products and features, based on the guidelines in references/product-mapping.md.
[ ] [ ] Step 3: Create architecture diagram: Generate an architecture diagram in Mermaid format: https://github.com/mermaid-js/mermaid.
[ ] [ ] Step 4: Generate design recommendations: Generate design guidance based on the guidelines in references/design-recommendations.md.
[ ] [ ] Step 5: Draft solution architecture: Compile the requirements, technical decomposition, product mapping, architecture diagram, and design recommendations into a single Markdown file named solution-architecture-guide.md, based on the template in assets/output-template.md.
[ ] [ ] Step 6: Request review: Present the generated solution architecture to the user and request their feedback or approval.
[ ] [ ] Step 7: Iterate: If the user requests changes, generate an updated solution architecture and repeat steps 2-6 until the user approves the solution architecture.

Phase 3: Implementation plan

[ ] [ ] Step 1: Retrieve relevant implementation resources:
Important: Use these resources as the technical foundation for the IaC and deployment instructions you generate in the remaining steps of this phase.
[ ] [ ] Step 2: Identify deployment prerequisites: Document prerequisites for the deployment, including the following:
- Projects and billing associations
- Required Google Cloud APIs
- Required IAM permissions
- Any other prerequisites
[ ] [ ] Step 3: Generate Infrastructure as Code (IaC): Generate code, like Terraform, and deployment scripts to automate the provisioning of the proposed Google Cloud resources.
[ ] [ ] Step 4: Write deployment instructions: Draft sequential, step-by-step deployment instructions to execute the IaC and initialize the workload components. Update deployment instructions in solution-architecture-guide.md, based on the template in assets/output-template.md.
[ ] [ ] Step 5: Request review: Present the generated deployment instructions to the user for feedback and confirmation.
[ ] [ ] Step 6: Iterate: If the user requests changes, then generate an updated implementation plan and repeat steps 2-5 until the user approves the implementation plan.

Phase 4: Solution validation

[ ] [ ] Step 1: Retrieve relevant verification resources (optional): If the resources from Phase 3 are not already in your context, retrieve the same implementation resources as the starting point for the validation checks and verification scripts that you generate in this phase.
[ ] [ ] Step 2: Define validation checks: Outline validation steps to verify that the deployed infrastructure meets the workload requirements:
- Deployment dry-run: Commands like terraform plan to preview changes.
- Connectivity and routing: Verification of network paths, load balancer routing, and service endpoints.
- Security policies: Verification of restricted access, firewall rules, and IAM enforcement.
[ ] [ ] Step 3: Generate verification scripts: Draft lightweight scripts or command-line instructions, such as using curl or gcloud, that the user can run to perform these validation checks.
[ ] [ ] Step 4: Compile validation report: Document the validation steps, verification scripts, and expected outcomes in solution-architecture-guide.md, based on the template in assets/output-template.md.
[ ] [ ] Step 5: Conduct validation and finalize: Assist the user in executing the validation checks and troubleshooting any deployment issues. After the solution is validated successfully, request final approval from the user.
[ ] [ ] Step 6: Iterate: If the user requests changes, then generate an updated validation plan and repeat steps 2-5 until the user approves the validation plan.

Files

ATTRIBUTION.mdAdded by AutoGineer930 B
LICENSELicence file added by AutoGineer11.1 KiB
SKILL.md9.2 KiB
assets/output-template.md8.5 KiB
references/attribution.md2.0 KiB
references/design-recommendations.md4.5 KiB
references/product-mapping.md4.9 KiB

assets/output-template.md

Google Cloud solution architecture: Live bidirectional multimodal streaming agentic AI solution

1. Executive summary and workload overview

[A brief description of the workload, its business goals, and the high-level solution architecture proposed.]

2. Requirements and current state

2.1. Functional requirements

Business processes: [Details of the business processes supported]
Activities and use cases: [Details of the key activities and use cases]

2.2. Non-functional requirements

Security: [Details of the security requirements including compliance, encryption, access control requirements]
Reliability: [Details of the reliability requirements including SLA, RTO/RPO, backup, redundancy requirements]
Cost: [Details of the cost constraints and pricing models]
Operations: [Details of the operational requirements including monitoring, logging, deployment, maintenance requirements]
Performance: [Details of the performance requirements including latency, throughput, scaling requirements]
Sustainability: [Details of the sustainability requirements including carbon footprint, resource optimization requirements]

2.3. Current state

[If applicable, describe the current on-premises or other-cloud architecture.]

Current infrastructure: [Details of existing setup]
Pain points and drivers for migration/redesign: [Details of the drivers for migration/redesign]

2.4. Dependencies

Internal dependencies: [Details of internal dependencies including other workloads and internal services]
External dependencies: [Details of external dependencies including third-party products and on-premises tools]

3. Technical decomposition of the workload

[Technical decomposition of the workload components, breaking down the application into logical services or layers.]

4. Proposed solution architecture

4.1. Google Cloud products and features mapping

[Identify Google Cloud products and features mapped to the technical components. For each component, justify the selection, note alternatives considered, and describe the pros and cons of the recommended product/feature and alternatives.]

Component	Recommended Google Cloud product/feature	Justification and citations	Alternatives considered	Pros and cons of alternatives
[Component Name Details (e.g. Frontend)]	[Product Name (e.g. Cloud Run)]	[Why this product is chosen, citing official docs]	[Alternative product (e.g. Firebase App Hosting)]	Pros: Automated builds and deployment pipeline from GitHub, optimized for modern framework integrations. <br> Cons: Less control over container configurations, limits customization of low-level networking.

4.2. Architecture diagram

[Architecture diagram in Mermaid format showing the relationships and flows between the components of the architecture.]

%% Example structure
graph TD
    User([User]) --> Web[Load Balancer]
    Web --> App[Application Layer]
    App --> DB[(Database)]

4.3. Architecture description

[Detailed description of the architecture. Describe the task flow and data flow between the components of the architecture.]

Data flow: [Describe the flow of data.]
Tasks/control flow: [Describe the flow of tasks/control.]

5. Design and configuration recommendations

[Best practices and configuration recommendations for each pillar of the Google Cloud Architecture Framework.]

5.1. Security, privacy, and compliance

Access control: [E.g., Disable default run.app URL, configure regional external Application Load Balancer with Cloud Armor for request filtering, rate limiting, and DDoS protection]
Data protection: [E.g., Enforce TLS encryption for bidirectional WebSocket connections to protect sensitive audio/video data, IAM least privilege policies]
Agent-to-Agent Security: [E.g., Extended agent cards with OIDC identity tokens for Agent2Agent (A2A) authentication]
Human oversight: [E.g., Human-in-the-loop flows to let supervisors monitor, pause, and override business-critical agent actions]

5.2. Reliability

Agent architecture: [E.g., Fault-tolerant agents with decentralized designs]
Staging and validation: [E.g., Simulate inter-agent coordination issues in replica staging environment]
High availability and quota: [E.g., Regional multi-zone Cloud Run deployment, Provisioned Throughput for critical production model workloads]

5.3. Operational excellence

Monitoring and logging: [E.g., Structured agent logs routed to Cloud Logging]
Tracing: [E.g., Cloud Trace and trace visualizers for agent reasoning loops and execution paths]
Continuous evaluation & tooling: [E.g., Agent Evaluation on Gemini Enterprise Agent Platform or ADK evaluation methodologies, MCP Database Toolbox for connection scaling policies]

5.4. Cost optimization

Data ingestion: [E.g., Low-frequency frame sampling and Base64 JPEG video compression]
Token optimization: [E.g., Context caching for long system prompts/static lookup databases, structured prompts for concise responses]
Model selection: [E.g., Starting with smaller models like Gemini Flash and upgrading to Gemini Pro for complex reasoning]

5.5. Performance efficiency

Media processing & buffering: [E.g., Asynchronous FIFO buffer decoupling incoming audio/video packets from model inference engine]
Low-latency storage: [E.g., In-memory Memorystore for Redis Cluster for agent schematic vault]
Compute sizing: [E.g., Fine-tuning Cloud Run memory and CPU limits based on live workloads]

5.6. Sustainability

Model routing: [E.g., Route simpler tasks to small language models (SLMs) to minimize inference footprint]
Serverless scaling: [E.g., Cloud Run native autoscaling to scale compute runtimes down to zero during idle periods]

6. Deployment guidance

[Instructions and code for deploying the architecture.]

6.1. Deployment prerequisites

[Prerequisite 1: E.g., Enabling APIs]
[Prerequisite 2: E.g., Installing SDK/tools]
...and so on

6.2. Step-by-step deployment instructions

[Step 1: E.g., Authenticate with Google Cloud]
[Step 2: E.g., Initialize Terraform]
[Step 3: E.g., Apply Terraform configuration]

7. Validation report

[Instructions and code for verifying that the deployed infrastructure meets the workload requirements.]

7.1. Validation checks

Deployment dry-run: [E.g., Running terraform plan to preview infrastructure changes]
Connectivity and routing: [E.g., Verifying VPC egress routing, load balancer service endpoints, and database connection state]
Security policies: [E.g., Checking IAM role constraints on the agent service accounts and verifying firewall rules]

7.2. Verification scripts

[Lightweight command-line checks or script configurations or cURL/gcloud commands to validate the deployed environment.]

Execution script 1:

# E.g., Script to test agent connectivity and endpoint response

Execution script 2:

# E.g., Script to verify IAM permissions and service mappings

8. References

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Published by

Google

Publisher

Google (Official)

Source

google/skills · skills/cloud/google-cloud-solution-agentic-ai-bidirectional-streaming · commit 2194d3b

Licence

Apache License 2.0 (redistribution allowed)

LICENSE (added by AutoGineer from LICENSE)
ATTRIBUTION.md (written by AutoGineer)

Synced

2026-11-08

AutoGineer is not affiliated with or endorsed by Google.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download google-cloud-solution-agentic-ai-bidirectional-streaming.zip