# Agentic Design Patterns: Google Cloud Reference

## Overview

**Agentic Design Patterns** are evolving, and leading cloud providers such as Google Cloud have been publishing white papers, blogs, and reference materials to catalog design patterns along with architecture and design guidelines.
This article highlights the key design patterns documented by the Google Cloud team and categorizes them as:
- **Core Execution Patterns (Single Agent / Task-Level)**
- **Multi-Agent Coordination Patterns**
- **Enterprise Deployment Topology Patterns**

This reference catalog summarizes the key patterns described in Google Cloud's agentic AI guidance: execution patterns for individual agent workflows, coordination models across multiple agents, and deployment topologies for production systems.

## Why This Matters

- As an Agentic AI architect, you need to ensure the Architecture Decisions (ADRs) are well-documented and applied as appropriate early in the [ADLC (Agent Development Lifecycle)](https://www.ibm.com/think/topics/agent-development-lifecycle-adlc).
- This document provides guidance to help you choose a design pattern for building an Agentic AI application. Agent design patterns are common architectural approaches for building agentic systems. An agent design pattern offers a unified framework for organizing a system's components, integrating the model, and orchestrating a single agent or multiple agents to accomplish a workflow.
- While agents help solve real-world problems and business use cases, their design plays a pivotal role in ensuring the agent's ROI and success.

## Design Patterns Catalog

| Pattern Category | Pattern | What It Does | Best Fit | Key Characteristics |
| --- | --- | --- | --- | --- |
| Core Execution Patterns | ReAct | Combines reasoning, tool use, and observation in an iterative loop until the task reaches a useful result. | Unstructured, exploratory, or dynamic tasks. | Stateful reasoning loop, action selection, tool invocation, observation-driven refinement. |
|  | Sequential (Pipeline) | Passes the output of one step directly into the next in a deterministic flow. | Workflows with clear ordered stages and predictable dependencies. | Low ambiguity, explicit stages, reusable intermediate outputs, easy debugging. |
|  | Parallel | Runs independent tasks or tool calls simultaneously to reduce latency and increase throughput. | High-volume or compute-intensive subwork. | Concurrency, fan-out/fan-in orchestration, reduced wall-clock time, independent work units. |
|  | Review-and-Critique | Uses a generator plus a critic or evaluator to review, validate, and refine outputs before finalizing. | Quality-sensitive tasks like code generation, drafting, or compliance review. | Feedback loop, validation, self-correction, stronger output quality. |
| Multi-Agent Coordination Patterns | Coordinator (Router / Dispatcher) | Delegates work to specialized agents based on request type, context, or capability. | Multi-skill or multi-domain workloads. | Central routing, specialization, task assignment, workload balancing. |
|  | Hierarchical (Tree / Multi-Tier) | Organizes agents into a parent/child structure where senior agents manage subgoals and delegate execution. | Complex workflows needing decomposition and supervision. | Parent-child control, nested planning, delegation, graded oversight. |
|  | Swarm / Peer-to-Peer | Lets autonomous agents communicate and hand off tasks dynamically without a single central controller. | Distributed collaboration and highly adaptive execution environments. | Decentralized coordination, peer negotiation, dynamic decision-making, emergent flow. |
| Enterprise Deployment Topology Patterns | Single-Agent System | Uses a single agent with tools and SDK integrations, usually deployed on serverless compute. | Lightweight enterprise workloads and proof-of-concept systems. | Simple architecture, lower operational overhead, direct tool access. |
|  | Multi-Agent System | Connects multiple specialized agents over service interfaces and messaging channels. | Partially decoupled enterprise systems with domain specialization. | Clear boundaries, service-level contracts, async communication, modular growth. |
|  | Multi-Agent Private Networking Pattern | Isolates communication through VPCs, private endpoints, and restricted network boundaries. | Regulated or security-sensitive environments. | Internal-only connectivity, reduced exposure, policy boundaries, secure service routing. |
|  | Multi-Tenant Agent System | Segregates resources and context across tenants with checks on access, resource usage, and governance. | Shared platforms serving multiple customers or departments. | Tenant isolation, access policy enforcement, governance controls, safe resource partitioning. |

### Pattern Selection Guidance

- Use a single-agent pattern when the workflow is focused and the task complexity is moderate.
- Use a coordinator or hierarchical model when multiple specialized skills need to be combined.
- Use parallel or review-and-critique patterns when latency, correctness, or evaluation quality matters.
- Use private networking or multi-tenant patterns when enterprise security, isolation, or compliance constraints dominate the architecture.

## Other Architecture Considerations

| Agent Layer | Purpose | Typical Components / Considerations | Architectural Notes |
| --- | --- | --- | --- |
| Agent Framework | Provides the runtime abstractions and orchestration primitives for building agents. | LangGraph, CrewAI, AutoGen, Google ADK, orchestration libraries. | Choose a framework based on workflow complexity, state handling, tooling, and enterprise deployment needs. |
| Agent Memory | Stores long-term and short-term context needed for continuity and personalization. | Session memory, vector memory, retrieval memory, state stores, conversation history. | Memory is critical for context retention, personalization, and reducing repeated re-discovery of facts. |
| Agent Evaluations | Measures quality, reliability, safety, and performance across prompts, tool use, and outcomes. | Golden datasets, offline evals, human review, trajectory analysis, rubric-based scoring. | Evaluation should be continuous and tied to quality gates before production rollout. |
| Agent Runtime | Executes the agent workflow, tool calls, and orchestration logic at runtime. | Serverless, containers, managed runtimes, execution engine, retries, throttling. | Runtime choices affect latency, scaling, cost, resilience, and operational manageability. |
| Agent Model Selection | Selects the most appropriate foundation model or model family for the task. | Frontier models, small models, multimodal models, routing policies, cost/performance tradeoffs. | Model choice should consider reasoning quality, latency, tool compatibility, and governance posture. |
| Agent Observability | Captures the internal decision path, tool traces, metrics, and operational issues. | Logging, tracing, telemetry, evaluation dashboards, prompt/response lineage. | Observability is essential for debugging, trustability, and diagnosing failures in production agent loops. |
| Agent Data Platform | Supports data access, context retrieval, indexing, and enterprise knowledge integration. | Vector databases, search indexes, data lakehouse, metadata systems, structured/unstructured stores. | High-quality data access is often the real determinant of agent usefulness and accuracy. |
| Agent Integration and Tools | Connects the agent to APIs, enterprise systems, workflows, and external services. | MCP servers, REST APIs, function calling, connectors, event streams, identity access. | Tool design and permission boundaries are central to reliable and secure agent behavior. |

## Key Takeaways

- Choose the agent design pattern based on the use case, business problem, and enterprise context.
- Catalog each architecture decision in the form of Architecture Decision Records (ADRs) as part of the enterprise.
- Choose the technology stack for each layer of the agent stack.
- The agent development lifecycle is not a one-off process; it is a continuous journey, given the evolving nature of the Agentic AI landscape.
- If you are aligned with Google Cloud, use the Google Cloud Well-Architected Framework for best practices and reference guidance.

## Patterns Visualization

![Agentic patterns visualization](https://vedcraft.com/images/2026/09/agentic-patterns.png)

## References

- [Google Cloud Architecture Center - Agentic Design Patterns](https://docs.cloud.google.com/architecture/choose-design-pattern-agentic-ai-system)
- [Google Cloud Well-Architected Framework](https://docs.cloud.google.com/architecture/framework)