Study guide
5.1 Agentic Architecture, ReAct Reasoning Loops & Orchestration
AWS Certified Generative AI Developer - Professional AIP-C01
Track your progress as you read
Finished sections get a check mark.
1 Chapter 1: Exam Overview & Foundation Model Fundamentals
1.1 AIP-C01 Exam Structure, Logistics & Passing Strategy 1.2 AIP-C01 Scoring & Professional Decision Strategy 1.3 Foundation Model Landscape & Model Selection on Amazon Bedrock 1.4 Model Abstraction, Controlled Switching & Resilience 1.5 Customization Spectrum: Prompting vs RAG vs Fine-Tuning vs Continued Pre-training 1.6 Custom Model Deployment & Lifecycle Management
2 Chapter 2: Bedrock Knowledge Bases & RAG Architectures
2.1 Managed RAG Architecture with Bedrock Knowledge Bases 2.2 Knowledge Source Integration, Synchronization & Freshness 2.3 Data Ingestion, Parsing & Chunking Strategies 2.4 Embedding Models & Vector Representations 2.5 Vector Index Scale, Migration & Retrieval Evaluation 2.6 Vector Database Selection: OpenSearch Serverless vs Aurora pgvector vs Managed Stores 2.7 Vector Store Security, Multi-Tenancy & Connectivity
3 Chapter 3: Advanced Vector Search, Indexing & Data Compliance
3.1 Hybrid Search, Metadata Filtering & Semantic Reranking 3.2 Metadata Filtering, Reranking & Query Transformation 3.3 Fine-Tuning & Continued Pre-Training Data Pipeline Engineering 3.4 Data Validation, Multimodal Processing & Model Formatting 3.5 Data Privacy, Data Residency & Compliance Governance 3.6 Privacy Preservation, Source Lineage & Audit Evidence
4 Chapter 4: Prompt Engineering & Bedrock Runtime APIs
4.1 Advanced Prompt Engineering Techniques & Inference Parameters 4.2 Inference Parameters, Prompt Governance & Regression 4.3 Converse API vs InvokeModel API & Message Formatting 4.4 Tool Calling, FM API Resilience & Model Routing 4.5 Streaming Architectures & Asynchronous Event Processing 4.6 Resilient Streaming, Deployment & Asynchronous Processing
5 Chapter 5: Amazon Bedrock Agents & Tool Integration
5.1 Agentic Architecture, ReAct Reasoning Loops & Orchestration 5.2 Agent Frameworks, MCP & Lifecycle Management 5.3 Action Groups, OpenAPI Schemas & AWS Lambda Integration 5.4 Agent Memory, Session State & Multi-Agent Collaboration Patterns 5.5 Persistent State & Multi-Agent Coordination 5.6 Advanced Agent Prompt Templates & Flow Customization 5.7 Agent Safeguards, Tool Reliability & Cost Control
6 Chapter 6: Workflow Orchestration & Application Integration
6.1 Amazon Bedrock Prompt Flows & Visual Orchestration 6.2 Step Functions Orchestration & Human-in-the-Loop Workflows 6.3 Enterprise Integration: API Gateway, AppSync, and EventBridge 6.4 Hybrid Integration, GenAI Gateways & CI/CD Tooling
7 Chapter 7: AI Safety & Guardrails for Amazon Bedrock
7.1 Guardrails Architecture, Denied Topics & Content Filters 7.2 Content Safety, Defense in Depth & Threat Detection 7.3 Sensitive Information Filters & PII Redaction/Masking 7.4 Contextual Grounding Checks & Hallucination Prevention
8 Chapter 8: Security, Access Control & Network Architecture
8.1 IAM Least Privilege & Resource Policies for Bedrock 8.2 PrivateLink VPC Endpoints & Network Isolation 8.3 Encryption with AWS KMS & Cross-Account Access Patterns
9 Chapter 9: Governance, Auditing & Operational Logging
9.1 SageMaker Model Cards & AI Governance Frameworks 9.2 Lineage, Fairness, Transparency & Continuous Governance 9.3 Invocation Logging, CloudTrail Auditing & Observability 9.4 Responsible AI, Bias Mitigation & Red Teaming Methodologies
10 Chapter 10: Performance, Throughput & Cost Optimization
10.1 On-Demand vs Provisioned Throughput & Capacity Planning 10.2 Capacity Measurement, Scaling Patterns & Resilience 10.3 Batch Inference & Bedrock Intelligent Prompt Routing 10.4 Intelligent Prompt Routing & Application Eligibility 10.5 Prompt Caching, Token Optimization & Latency Reduction
11 Chapter 11: Testing, Evaluation & Troubleshooting GenAI Solutions
11.1 Amazon Bedrock Model Evaluation (Automatic & Human Workflows) 11.2 Human, RAG & Continuous Evaluation 11.3 Evaluation Metrics & RAG Quality Benchmarking (Ragas, ROUGE, BLEU) 11.4 RAG and Agent Performance Evaluation 11.5 CloudWatch Metrics, Throttling & Operational Observability 11.6 Quota Diagnosis, Retry Control & Operational Troubleshooting 11.7 Troubleshooting Common GenAI Failure Modes & Agent Traces 11.8 Prompt Maintenance, Content Handling & Deployment Validation
5.1 Agentic Architecture, ReAct Reasoning Loops & Orchestration
Key Takeaways Explain This Topic AI
Amazon Bedrock Agents extend static foundation models into autonomous systems that break down multi-step user prompts into sequential logic and automated tool invocations.
The agent orchestration engine executes a ReAct (Reasoning and Acting) loop, cycling through Thought formulation, Action selection, Action execution, and Observation evaluation until reaching a final answer.
Every Bedrock Agent integrates five core architectural pillars: a foundation model (such as Claude 3.5 Sonnet), system instructions, action groups for business logic, knowledge bases for contextual retrieval, and guardrails for safety.
Agent lifecycle management enforces immutable releases: developers edit a mutable DRAFT version, build compiled runtime artifacts with PrepareAgent, publish immutable numeric versions, and direct traffic via Aliases with routing configurations.
Stateful conversation across turns is maintained through the client-provided sessionId parameter in the InvokeAgent API, preserving working context within a configurable idle session time-to-live.
Last updated: September 2026
5.1 Agentic Architecture, ReAct Reasoning Loops & Orchestration
This independent study guide by ExamFinch helps candidates prepare for the AWS Certified Generative AI Developer - Professional (AIP-C01) examination. While foundational generative AI workflows rely on single-turn text synthesis or basic Retrieval-Augmented Generation (RAG), production enterprise applications increasingly require autonomous systems capable of executing complex, multi-step business processes. Amazon Bedrock Agents provide a fully managed orchestration runtime that bridges foundation models (FMs) with enterprise APIs, databases, and knowledge repositories, transforming reactive language models into proactive, task-executing digital agents.
Fundamentals of Amazon Bedrock Agents
At its core, an Amazon Bedrock Agent is an autonomous orchestrator that interprets user intent, formulates a logical execution plan, decomposes ambiguous problems into granular steps, calls external tools to gather information or trigger transactions, and synthesizes grounded final responses.
Traditional application workflows rely on deterministic, hardcoded decision trees (such as AWS Step Functions state machines or custom procedural code). While deterministic workflows excel when business rules are rigid, they struggle with dynamic user intent, unstructured natural language instructions, and unpredictable task paths. Conversely, Amazon Bedrock Agents employ the cognitive reasoning capabilities of foundation models to decide dynamically at runtime which tools to call, what parameters to supply, and whether additional steps are required based on intermediate findings.
Key Agent Capabilities
Dynamic Task Decomposition : Breaking high-level user requests (e.g., "Cancel flight FL-402, find the next flight to Seattle under $300, and notify the traveler via SMS") into discrete subtasks executed in optimal sequence.
Autonomous Tool Execution : Selecting appropriate external APIs (Action Groups) and extracting parameter arguments directly from conversation context.
Grounded Information Retrieval : Querying Bedrock Knowledge Bases to augment reasoning with proprietary corporate data.
Multi-Turn Context Retention : Retaining conversational history and session-scoped attributes across user exchanges.
The ReAct (Reasoning + Acting) Framework
Amazon Bedrock Agents manage orchestration using the ReAct (Reasoning and Acting) framework. Proposed in modern AI research, ReAct synergizes reasoning traces with task-specific actions. By generating reasoning steps before taking action, the agent reduces hallucination, tracks state changes, and adjusts its plan dynamically based on environmental feedback.
The ReAct loop within Amazon Bedrock proceeds through an iterative cycle: ┌───────────────────────────────────┐
- │ User Request │
- └─────────────────┬─────────────────┘
- │
- ▼
- ┌───────────────────────────┐
- │ 1. Thought Formulation │
- │ (Model reasons over task)│
- └─────────────┬─────────────┘
- │
- ▼
- ┌───────────────────────────┐
- │ 2. Action Selection │
- │ (Selects tool & parameters)│
- └─────────────┬─────────────┘
- │
- ▼
- ┌───────────────────────────┐
- │ 3. Action Execution │
- │ (Calls Lambda or KB) │
- └─────────────┬─────────────┘
- │
- ▼
- ┌───────────────────────────┐
- │ 4. Observation Analysis │
- │ (Model inspects result) │
- └─────────────┬─────────────┘
- │
- ┌────────────────┴────────────────┐
- ▼ ▼
- [Goal NOT Satisfied] [Goal Satisfied]
- (Iterate ReAct Cycle) (Synthesize Output)
- │ │
- └─────────────────┐ │
- │ ▼
- │ ┌─────────────────┐
- └─────>│ Final Answer │
- └─────────────────┘
- Step-by-Step ReAct Execution Breakdown
Thought : The foundation model analyzes the user's initial input along with conversational history and intermediate scratchpad logs. It articulates a natural language reasoning statement describing what information is missing or what operational action must be executed next.
Action : Based on the thought, the model specifies an action. This consists of selecting a specific tool from an Action Group (e.g., GetCustomerAccountBalance ) or initiating a search against an attached Knowledge Base.
Action Input : The model constructs the concrete parameters required by the selected tool, extracting values from the conversation or previous observations (e.g., {"customerId": "CUST-9012", "currency": "USD"} ).
Observation : Bedrock executes the action (for example, invoking an AWS Lambda function) and returns the raw output into the agent's internal working context (the agent scratchpad ).
Evaluation & Termination : The model evaluates the observation. If the retrieved data is insufficient to fulfill the user's original objective, the agent enters a subsequent ReAct iteration, formulating a new Thought. If the goal is satisfied, the agent synthesizes the final response and exits the loop.
Note
To prevent runaway execution and unbounded inference costs, Amazon Bedrock enforces internal orchestration step limits. If an agent fails to reach a terminating condition within the configured step ceiling, it aborts the loop and returns a fallback message to the caller.
Core Components of an Amazon Bedrock Agent
An Amazon Bedrock Agent is constructed from five foundational building blocks:
Component Architectural Purpose Example Configuration
Foundation Model Serves as the cognitive reasoning engine driving the ReAct loop, tool parameter extraction, and response generation. Anthropic Claude 3.5 Sonnet, Claude 3 Haiku, Amazon Nova Pro
Instruction Prompt Global natural-language system instructions establishing persona, operational boundaries, formatting rules, and fallback behavior. "You are an enterprise HR assistant. Always verify employee IDs before modifying benefits. Never disclose executive salary data."
Action Groups Bridges between the agent and external APIs or business logic, defined using OpenAPI 3.0 schemas or inline functions with AWS Lambda targets. ManageLeaveRequests , QueryInventoryDatabase , SendNotificationService
Knowledge Bases Fully managed RAG integration connecting the agent to indexed corporate documentation stored in vector repositories. HR-Policy-KB linked to Amazon OpenSearch Serverless
Guardrails for Bedrock Safety layer enforcing denied topics, content filters, PII masking, and contextual grounding across all agent inputs and outputs. Enterprise-Compliance-Guardrail with strict financial advice blocks