Amazon Web Services AIP-C01 Dumps

The correct combination is C and D because together they enforce centralized governance over both model access and prompt content controls , which are the two core requirements of the scenario.

To ensure employees can use only approved Amazon Bedrock models , governance must be enforced at the organization level and not rely on individual application logic. Service Control Policies (SCPs) are the strongest control mechanism available in AWS Organizations because they define the maximum permissions an account or principal can have. In option C , the SCP prevents any Amazon Bedrock model invocation unless a centrally approved guardrail identifier is specified. This ensures that guardrails are always enforced, regardless of how or where the invocation originates. The additional use of IAM permissions boundaries ensures that even within allowed accounts, employees are restricted to invoking only explicitly approved foundation models.

To prevent specific topics and proprietary information from being included in prompts , Amazon Bedrock Guardrails must be used. Guardrails operate inline during model invocation and can block disallowed content before it is processed by the model. Option D correctly specifies a block filtering policy , which is appropriate when content must be prevented entirely rather than partially redacted. Deploying the guardrail using AWS CloudFormation StackSets allows the company to centrally manage and consistently deploy the same guardrail configuration across all accounts in the organization, ensuring uniform enforcement.

Option E uses mask filtering, which is better suited for redacting sensitive output rather than preventing prohibited content from being submitted in prompts. Option B attempts to use SCPs alone but does not enforce guardrail deployment or content filtering. Option A incorrectly places guardrail enforcement in permissions boundaries, which are not designed to validate request parameters such as guardrail identifiers.

By combining SCP-based enforcement with centrally deployed Bedrock guardrails , options C and D together provide strong, scalable, and centrally managed controls for both content safety and model governance across the organization.

Option A best satisfies the requirement to capture multi-hop, highly interconnected relationships with minimal operational overhead. Traditional vector similarity search excels at finding semantically similar text but is not optimized for reasoning over explicit entity-to-entity relationships, especially when analysts need indirect, multi-hop connections (for example, fund → holding → issuer → sector → regulation). Graph-based retrieval is designed specifically for these kinds of relationship traversals.

GraphRAG combines retrieval-augmented generation with graph-aware context selection. By representing entities and their relationships in a graph store, the system can traverse multiple hops to assemble a holistic set of relevant facts. This improves completeness and reduces the chance that the model misses indirect relationships that are essential for accurate investment guidance.

Amazon Neptune Analytics provides a managed graph analytics environment capable of efficiently traversing and analyzing complex relationship networks. When integrated with Amazon Bedrock Knowledge Bases, it reduces custom engineering by providing managed ingestion, retrieval, and orchestration patterns suitable for GenAI applications. This lowers operational overhead compared to building and maintaining custom multi-stage retrieval logic.

Meeting the sub-3-second requirement is also more feasible with a graph-optimized engine because multi-hop traversals can be executed efficiently compared to chaining multiple vector searches and joining results in an application layer. The managed nature of Knowledge Bases and Neptune Analytics reduces maintenance, scaling, and operational burden while enabling strong performance.

Option B and C require extensive custom logic and orchestration, increasing complexity and latency. Option D is not designed for graph-style multi-hop exploration and would require significant custom indexing and retrieval logic.

Therefore, Option A is the most AWS-aligned and operationally efficient approach for multi-hop relationship-aware RAG with strong performance.

Option A is the correct solution because it satisfies authentication, private connectivity, fine-grained authorization, and auditing using AWS-recommended patterns.

SAML federation between Microsoft Entra ID and IAM is a mature, well-supported integration that enables centralized enterprise authentication. Department-specific IAM roles allow precise control over which Bedrock ModelId values each department can invoke, enforcing access by model family.

Using AWS PrivateLink interface VPC endpoints for Amazon Bedrock runtime services ensures that all inference traffic stays on private AWS network paths, with no public internet exposure. NAT gateways and public endpoints, as used in other options, violate this requirement.

AWS CloudTrail provides authoritative audit logs of all Bedrock API calls, which is required for compliance. Amazon Bedrock model invocation logging complements CloudTrail by capturing detailed prompt and response metadata for deeper auditing and investigation.

Option B uses public endpoints via NAT. Option C incorrectly claims public endpoints can be private. Option D relies on IdP-side logs, which do not capture Bedrock API activity.

Therefore, Option A is the only solution that fully meets security, compliance, and observability requirements.

Option A is the correct answer because Amazon Bedrock Flows is purpose-built to orchestrate generative AI workflows that combine data access, deterministic transformations, and model invocation with minimal operational overhead. The requirements explicitly state that the workflow must retrieve content from Amazon S3, extract a specific portion of a predefined template, send that portion to an Amazon Bedrock model, and store the model’s response back into the same S3 bucket. Amazon Bedrock Flows natively supports all of these steps.

By configuring S3 action nodes at the beginning and end of the flow, the workflow can retrieve the original communications and persist the reviewed output without custom code. The expression step allows deterministic parsing of a specific portion of the template, which is essential when only part of the message should be reviewed. This avoids relying on generative logic for parsing, which would be less predictable and harder to audit. The agent step is then used specifically for the review task, where the foundation model evaluates or modifies the extracted content.

Option B uses AWS Step Functions, which can achieve similar outcomes but requires more explicit orchestration logic and does not provide GenAI-native constructs such as expressions and agent steps in a single managed experience. Options C and D rely on Amazon Bedrock agents and AWS Lambda functions to handle parsing and data movement, which increases complexity, operational overhead, and maintenance burden.

Because Amazon Bedrock Flows directly integrates S3 actions, parsing expressions, and model review steps in a single managed workflow, Option A best meets the requirements with the least development and operational effort.

Option B best meets the latency, resilience, and data residency requirements while keeping operational complexity low by using built-in Amazon Bedrock cross-Region inference behavior through inference profiles . Cross-Region inference profiles are designed to provide higher availability and better traffic absorption when a single Region experiences throttling, transient capacity constraints, or quota-related degradation. By selecting the appropriate geography-scoped inference profile (for example, a Europe-scoped profile for European users and a North America-scoped profile for North American users), the application can keep inference traffic within the required geographic boundary. This directly supports EU data residency needs because European requests can be served only by Europe-based Regions while still benefiting from multi-Region resilience inside Europe.

The question also highlights degradation when Regional traffic spikes hit quotas. Cross-Region inference profiles help mitigate these conditions by allowing Bedrock to serve requests from another Region within the same geography, improving continuity during spikes without requiring the company to implement custom retry-and-failover logic across Regions. This reduces development and operational burden compared to building and maintaining a bespoke routing and fallback system.

Using separate Amazon API Gateway HTTP APIs to direct European and North American users to the correct endpoints simplifies request routing and provides a clean boundary for compliance controls, logging, and monitoring. It also allows each geography to scale independently and maintain consistently low latency by keeping users close to the entry point and the Bedrock geography they must use.

Option A requires custom routing and manual operational monitoring and does not inherently solve quota-driven degradation. Option C adds significant complexity by embedding throttling retries and cross-Region selection logic in Lambda while still needing careful controls to prevent cross-border routing mistakes. Option D introduces the highest operational complexity and can inadvertently violate residency if failover crosses geographies unless additional safeguards are implemented.

Option C best satisfies the requirement to change routing decisions without redeploying code while supporting complex, frequently changing business logic at scale. AWS AppConfig is designed for centrally managing dynamic configuration (feature flags, rules, thresholds, and policy parameters) and deploying changes safely. It supports controlled deployments, validation, and rapid propagation of updated configuration values, which aligns with “real-time cost metrics that change hourly” and the need for “immediate propagation across thousands of concurrent requests.”

In this design, the Lambda function becomes the policy decision point. For each request, it evaluates user attributes (tier, transaction value), context (regulatory zone, Region), and live cost/performance thresholds stored in AppConfig to determine which Amazon Bedrock FM to invoke. Because the routing rules and FM identifiers are delivered as configuration, the company can switch models, adjust A/B testing weights, or update compliance routing rules by deploying new AppConfig configuration versions rather than pushing new application code. This reduces operational risk and accelerates iteration.

Exposing a single API Gateway endpoint also minimizes client complexity and keeps routing logic server-side, which is important when rules change frequently. Lambda can cache configuration between invocations (within the execution environment) to reduce repeated fetch overhead while still picking up changes quickly, enabling both low latency and rapid rule rollout under high concurrency.

Option A relies on Lambda environment variables, which are not intended for frequent real-time updates and typically require function configuration updates that are slower and operationally brittle. Option B uses mapping templates and stage variables, which are limited for complex rule evaluation and safe rollout patterns. Option D misuses authorizers for business routing, adds extra latency and complexity, and complicates observability and error handling by splitting decisioning from execution.

Option B is the correct solution because it aligns with AWS guidance for building high-throughput, ultra-low-latency GenAI applications while maintaining predictable costs and automatic scaling. Amazon Bedrock provides access to foundation models that are specifically optimized for real-time inference use cases, including conversational and recommendation-style workloads that require responses within milliseconds.

Low-latency models in Amazon Bedrock are designed to handle very high request rates with minimal per-request overhead. Purchasing provisioned throughput ensures that sufficient model capacity is reserved to handle peak loads, eliminating cold starts and reducing request queuing during traffic surges. This is critical when supporting up to 500,000 concurrent calls with strict latency requirements.

Automatic scaling policies allow the application to dynamically adjust capacity based on demand, ensuring cost efficiency during off-peak hours while maintaining performance during peak usage. This directly supports the requirement to stay within a predefined monthly compute budget.

Option A fails because batch processing and complex reasoning models introduce higher latency and are not suitable for real-time suggestions. Option C introduces significantly higher operational and cost overhead due to dedicated GPU instances and manual scaling responsibilities. Option D is optimized for batch workloads and cannot meet the sub-200 ms latency requirement.

Therefore, Option B provides the best balance of performance, scalability, cost control, and operational simplicity using AWS-native GenAI services.

Option B is the correct solution because it directly addresses both throughput bottlenecks and latency requirements using native Amazon Bedrock performance optimization features that are designed for real-time, high-volume generative AI workloads.

Amazon Bedrock supports cross-Region inference profiles, which allow applications to transparently route inference requests across multiple AWS Regions. During peak usage periods, traffic is automatically distributed to Regions with available capacity, reducing throttling, request queuing, and timeout risks. This approach aligns with AWS guidance for building highly available, low-latency GenAI applications that must scale elastically across geographic boundaries.

Token batching further improves efficiency by combining multiple inference requests into a single model invocation where applicable. AWS Generative AI documentation highlights batching as a key optimization technique to reduce per-request overhead, improve throughput, and better utilize model capacity. This is especially effective for lightweight, low-latency models such as Claude 3 Haiku, which are designed for fast responses and high request volumes.

Option A does not meet the requirement because purchasing provisioned throughput in a single Region creates a regional bottleneck and does not address multi-Region availability or traffic spikes beyond reserved capacity. Retries increase load and latency rather than resolving the root cause.

Option C improves application-layer scaling but does not solve model-side throughput limits. Client-side round-robin routing lacks awareness of real-time model capacity and can still send traffic to saturated Regions.

Option D is unsuitable because batch inference with asynchronous retrieval is designed for offline or non-interactive workloads. It cannot meet a strict 2-second response time requirement for an interactive AI assistant.

Therefore, Option B provides the most effective and AWS-aligned solution to achieve low latency, global scalability, and high throughput during peak usage periods.

Option D is the correct solution because it directly satisfies all three core requirements: data source registration, metadata-based attribution, and end-to-end audit logging, while remaining service-agnostic and scalable across internal and external data sources.

The AWS Glue Data Catalog is the AWS-native service for registering datasets and managing metadata centrally. It supports structured registration of diverse data sources and enables consistent tagging that can be used to attribute generated content back to its original source. This is essential for GenAI applications that combine multiple datasets and must provide traceability for outputs.

Metadata tags applied within the Glue Data Catalog ensure a consistent attribution framework that downstream systems—such as Retrieval Augmented Generation (RAG) pipelines or evaluation systems—can reference without embedding attribution logic directly in application code. This improves maintainability and governance.

AWS CloudTrail provides immutable audit logs of API activity across AWS services, including data access, metadata changes, and pipeline interactions. CloudTrail logs are critical for compliance and regulatory review because they capture who accessed which data, when, and through which service. This satisfies the requirement to maintain audit logs “throughout the pipeline,” not just at storage or application layers.

Option A introduces Lake Formation, which is primarily intended for fine-grained data lake permissions and is not required solely for traceability. Option B relies on CloudWatch Logs, which does not provide authoritative audit logging across services. Option C limits audit scope to S3 access and does not register or govern all data sources comprehensively.

Therefore, Option D provides the most complete and least intrusive solution for traceable, auditable GenAI data pipelines.

Option B best meets all requirements because it combines AWS-recommended resiliency patterns for transient failures with streaming-aware handling and adaptive protection against cascading retries during peak load. When timeouts and throttling occur, naïve retries can amplify traffic and worsen outages. Exponential backoff with jitter is the standard AWS best practice because it spreads retry attempts over time, reduces synchronized retry storms, and lowers the probability of repeatedly colliding with service limits.

The requirement also states the strategy must “adapt to changing service availability” and “prevent overwhelming Amazon Bedrock.” A circuit breaker pattern directly addresses this by temporarily stopping or reducing retries when failure rates exceed a threshold, allowing the system to degrade gracefully instead of continually hammering the service. This is a key mechanism to prevent cascading failures during throttling events.

Because the application uses response streaming and experiences broken chunks, the retry strategy must be streaming-aware. A streaming response handler that detects chunk delivery timeouts and buffers already received chunks prevents the user from losing progress when a connection drops. Resuming from the last successfully received chunk minimizes redundant generation and reduces additional load on the model compared with restarting the entire stream. This supports better user experience and better service efficiency during intermittent failures.

Token-aware request handling is supported in this architecture because the application can apply token budgeting before invoking the model (for example, trimming or summarizing excessive context) while still preserving streaming output behavior. Option B provides the correct backbone for this by focusing on adaptive control and robust streaming recovery.

Option A is too simplistic and risks retry storms. Option C combines conflicting elements (global token limit, cached completions for streaming) and includes impractical “request only missing chunks” behavior that is not a reliable property of streamed generative output. Option D includes useful ideas (load shedding) but relies on static caps and does not provide as strong adaptive retry control as circuit breaking.

Therefore, Option B is the most correct and operationally safe strategy for peak-load Bedrock streaming workloads.

Option B is the correct solution because Amazon Bedrock Prompt Management is purpose-built to manage, govern, and standardize prompt usage at scale across teams and Regions. It provides native version control, allowing teams to track prompt changes over time and ensure that only approved versions are used in production workflows.

Prompt Management supports approval workflows that align with enterprise governance requirements. Approval permissions can be enforced through IAM policies, ensuring that only authorized reviewers can approve or publish prompt versions. This removes the need for custom workflow engines or external storage systems, significantly reducing operational overhead.

Parameterized prompt templates enable consistent prompt structure while allowing controlled variation through defined variables. This ensures consistent quality standards and reduces prompt drift, which is critical when hundreds of prompts are reused across multiple applications and teams.

AWS CloudTrail integrates natively with Amazon Bedrock to provide immutable audit logs for prompt creation, updates, approvals, and usage. These detailed audit trails satisfy compliance requirements and allow security and governance teams to trace prompt activity across Regions and users.

Option A requires significant custom development to coordinate approvals and maintain state. Option C relies on general-purpose workflow services and manual versioning mechanisms that are error-prone and difficult to scale. Option D uses services not designed for large-scale GenAI prompt governance and introduces unnecessary complexity.

Therefore, Option B best meets the requirements for scalable, auditable, and low-overhead governance of AI-generated content using Amazon Bedrock.

Option B best satisfies the requirements with the least custom development effort by using native Amazon Bedrock capabilities for prompt experimentation, traffic management, fairness monitoring, and alerting. Amazon Bedrock Prompt Management allows teams to define and manage multiple prompt variants without code changes, making it ideal for comparing recommendation strategies across demographic groups.

Amazon Bedrock Flows enables controlled traffic allocation between prompt variants, which supports real-time A/B testing. This allows the company to collect live fairness metrics under production conditions instead of relying on offline analysis. Because Flows are fully managed, they eliminate the need for custom routing or experimentation frameworks.

Amazon Bedrock guardrails provide built-in monitoring and intervention mechanisms. When configured for fairness-related checks, guardrails can detect policy violations and surface metrics such as InvocationsIntervened, which indicate when outputs are modified or blocked due to rule enforcement. These metrics integrate directly with Amazon CloudWatch, enabling real-time dashboards and threshold-based alarms. Setting an alarm at a 15% discrepancy threshold satisfies the alerting requirement with minimal configuration.

Weekly reporting can be generated from CloudWatch metrics using scheduled exports or dashboards without building custom analytics pipelines. Option A requires significant custom post-processing logic. Option C introduces an additional service with higher operational overhead and is not optimized for real-time monitoring. Option D focuses on offline evaluation jobs and does not provide continuous real-time fairness monitoring.

Therefore, Option B provides the most AWS-native, scalable, and low-effort solution for fairness evaluation and monitoring.

When a foundation model fails to include specific required content or fails to integrate it coherently, prompt engineering techniques like output indicators or " wrappers " are highly effective. By explicitly defining where the promotional message should appear (e.g., " The response must end with the following message: [PROMO TEXT] " ) or providing an example output structure, the developer reinforces the constraint within the model ' s generation path. This is more direct and less computationally expensive than generating multiple variants and reranking them (Option B) or adding complex post-processing layers (Option C). Guardrails (Option A) are intended for filtering harmful content rather than enforcing specific promotional copy insertion.

Option B is the correct solution because it parallelizes independent foundation model inference tasks while maintaining orchestration, observability, and time-bound execution. AWS Generative AI best practices emphasize reducing end-to-end latency by parallelizing independent inference calls rather than scaling individual calls vertically.

In this scenario, each report requires multiple independent analyses such as financial extraction, sentiment analysis, and compliance validation. These tasks do not depend on each other’s output, making them ideal candidates for parallel execution. AWS Step Functions provides a Parallel state that can invoke multiple AWS Lambda functions simultaneously, drastically reducing total processing time compared to sequential execution.

By invoking Amazon Bedrock from separate Lambda functions in parallel, the system can reduce batch execution time from 45 seconds to well under the 10-second requirement, assuming each inference call remains within acceptable latency bounds. Step Functions also provide built-in error handling, retries, and state tracking, which improves reliability without increasing complexity.

CloudWatch metrics allow teams to monitor both workflow execution time and individual model inference latency, enabling performance tuning and operational visibility. Configuring client-side timeouts ensures that slow or failed model invocations do not block the entire batch.

Option A still processes tasks sequentially and therefore cannot meet the strict latency requirement. Option C introduces queuing delays and sequential processing within each report, which increases total execution time. Option D relies on container-based sequential processing and adds unnecessary operational overhead for a workload that is event-driven and latency-sensitive.

Therefore, Option B best meets the performance, scalability, and operational efficiency requirements for high-speed batch document analysis using Amazon Bedrock.

The correct combination is B and C because together they address both workload diversity and hybrid deployment requirements with minimal custom engineering.

Option B provides consistent, high-throughput access by configuring provisioned throughput in Amazon Bedrock. Provisioned throughput guarantees predictable capacity and performance, which is essential for batch processing workloads that require sustained inference rates. This eliminates cold starts and throttling concerns that can occur with purely on-demand usage, making it well suited for high-volume enterprise workloads.

Option C enables hybrid deployment across cloud and on-premises environments by deploying foundation models to Amazon SageMaker AI endpoints and using Amazon SageMaker Neo for edge and on-premises optimization. SageMaker Neo compiles models for target hardware, allowing inference to run efficiently outside the AWS cloud while still using AWS-managed tooling. Orchestrating these deployments with AWS Lambda allows consistent invocation patterns across environments.

Option A uses asynchronous endpoints, which are not suitable for real-time, low-latency inference. Option D addresses scaling but does not support on-premises or hybrid deployment. Option E simplifies model onboarding but does not address hybrid execution or guaranteed throughput.

Therefore, Options B and C together provide real-time and batch support, predictable performance, and true hybrid deployment while minimizing operational overhead.

Option D is the correct solution because Amazon Q Developer customizations are designed to incorporate organization-approved knowledge and coding guidance without requiring per-project changes. A customization can point Amazon Q Developer to curated internal sources such as approved libraries, coding standards, architectural patterns, and proprietary techniques. This allows the assistant’s suggestions to align with company policies and preferred implementations consistently across teams and repositories.

The key requirement is that the company does not want to make project-level modifications. Options A, B, and C all require adding files or repositories into the project workspace, which directly violates this constraint. They also rely on developer behavior to “use workspace context,” which is harder to enforce and can lead to inconsistent adherence to standards.

With a customization, the organization centrally manages and updates approved resources. This reduces operational overhead because updates to libraries, patterns, or guidelines propagate automatically to developers using the customization, without requiring changes to each project. This is especially valuable for a new team, where consistent enforcement of approved practices is important to reduce compliance risk, security issues, and inconsistent code style.

Additionally, customizations support governance by allowing the company to standardize how Amazon Q Developer responds, ensuring that suggestions reflect approved internal content rather than generic public patterns.

Therefore, Option D best satisfies the requirement for centralized enforcement of approved resources with minimal ongoing management and no project-level modifications.

Option A is the best solution because it natively delivers retrieval grounding, source attribution, and low operational overhead through Amazon Bedrock Knowledge Bases. The key requirements are: retrieve from company data sources, cite sources, link claims to source documents, and keep latency under 3 seconds. Knowledge Bases are a managed RAG capability that handles document ingestion, chunking, embeddings, retrieval, and assembly of context for model generation. This eliminates the need to build and maintain custom retrieval infrastructure.

Source attribution is crucial: the application must “link data claims to source documents.” When source attribution is enabled, the RAG pipeline can return references to the underlying documents and segments used for generation. This enables traceable citations that can be surfaced to end users and used for internal auditing.

Using the Anthropic Claude Messages API (or equivalent conversational interface) with RAG allows the application to generate recommendations grounded in retrieved context while keeping responses conversational. Setting relevance thresholds helps reduce noisy retrieval, which supports both accuracy and latency targets by limiting the context passed to the model.

Storing reasoning and citations in Amazon S3 supports audit and retention needs with minimal operational burden. While the prompt may request step-by-step reasoning, AWS best practice is to produce user-facing explanations that are faithful and attributable without exposing internal reasoning traces unnecessarily. With source-grounded outputs, the system can provide concise rationale tied to citations while maintaining fast response times.

Option B emphasizes extended thinking, which increases latency and does not ensure source linkage. Option C adds significant operational overhead through custom model hosting and separate citation systems. Option D requires more custom tracking work than A while not improving retrieval attribution beyond what Knowledge Bases already provide.

Therefore, Option A best meets the requirements with the least operational overhead.

For a 3-week proof-of-concept in a regulated field like healthcare, Retrieval Augmented Generation (RAG) is more efficient and safer than fine-tuning. RAG allows the use of anonymized patient records without risking the leak of sensitive data into the model ' s permanent memory. To evaluate accuracy quantitatively and rapidly, the " LLM-as-a-judge " pattern is recommended. Using a strong judge model to score the outputs of multiple candidate FMs provides objective metrics (e.g., factual alignment, completeness) that manual qualitative feedback (Option C) cannot scale to provide within the timeline. Fine-tuning (Option B) typically takes longer than 3 weeks to properly data-prep and validate for clinical accuracy.

The correct answers are B and C because they directly address hallucination reduction while maintaining high throughput and low latency.

Option B reduces hallucinations at their source by grounding model outputs in verified content through Retrieval Augmented Generation (RAG). Using an Amazon Bedrock knowledge base with semantic chunking ensures that long technical documents are broken into meaningfully coherent sections. This allows the model to retrieve only the most relevant chunks, rather than processing an entire document in one pass, which significantly improves factual accuracy and reduces cognitive overload on the model. This approach scales efficiently and supports processing more than 1,000 documents per hour.

Option C adds a defense-in-depth safety layer by using Amazon Bedrock guardrails to detect and block hallucination-like output patterns. Guardrails operate at inference time with minimal performance overhead, making them suitable for low-latency requirements. While guardrails do not eliminate hallucinations entirely, they effectively prevent unsafe or clearly fabricated outputs from reaching users.

Option A increases latency and cost due to explicit reasoning steps and does not scale well for high-throughput workloads. Option D increases randomness and worsens hallucinations. Option E repeats the existing flawed approach.

Therefore, Options B and C together provide scalable grounding and runtime protection that meet accuracy, performance, and throughput requirements.

Option D is the correct solution because it directly evaluates multilingual output consistency and quality in an automated, scalable, and deployment-gating workflow. Amazon Bedrock model evaluation jobs are designed to run large-scale, repeatable evaluations against defined datasets and to produce quantitative metrics that can be used as objective release criteria.

The core issue is semantic inconsistency across languages for equivalent inputs. The most reliable way to detect this is to create standardized test conversations where each language version expresses the same intent and constraints. Running those tests through the updated model and comparing results with similarity metrics (for example, semantic similarity between expected and actual answers, or between language variants) surfaces regressions that infrastructure testing cannot detect.

Bedrock evaluation jobs support running evaluations at scale and are well suited for processing large datasets quickly. By parallelizing evaluation runs across languages and conversations, the company can meet the 45-minute requirement while executing at least 15,000 conversations. Because the process is standardized, it also allows consistent baseline comparisons across releases.

Applying hallucination thresholds ensures that answers remain grounded and do not introduce fabricated details, which is particularly important when language-specific behavior shifts after a model upgrade. Integrating evaluation jobs into the CI/CD pipeline enables fully automated execution on every model or configuration update. The pipeline can enforce a hard quality gate that blocks deployment if thresholds are not met, preventing regressions from reaching production.

Option A focuses on performance and infrastructure bottlenecks, not multilingual response quality. Option B is post-deployment and too slow to prevent regressions. Option C normalizes inputs but does not measure multilingual output equivalence or provide robust, quantitative gating.

Therefore, Option D best meets the automation, scale, timing, and deployment-blocking requirements.

AWS Glue Data Catalog and its associated crawlers are the standard AWS tools for automatic discovery and centralized cataloging of datasets. For the generated summaries, storing them in Amazon S3 allows the use of object tags for metadata (like source IDs), making them easily queryable. The critical requirement for " tamper-evident, immutable audit logs " is met by enabling Bedrock model invocation logging to an S3 bucket protected by S3 Object Lock (compliance mode). To further guarantee that logs have not been altered, AWS CloudTrail log file integrity validation uses cryptographic hashes to provide non-repudiation and a verifiable audit trail. This combination covers data management, metadata attribution, and high-standard security compliance.

Option B is the best solution because it directly addresses the Step Functions 256 KB state payload quota by externalizing large intermediate artifacts to Amazon S3 and passing only lightweight references (URIs/keys) between states. This is a standard AWS pattern for workflows that produce large intermediate results, and it avoids introducing additional databases, compression logic, or cross-state-machine coordination that increases operational overhead.

In a multi-agent ReAct workflow, intermediate reasoning traces can be verbose and grow quickly as each agent produces chain-of-thought style artifacts, structured outputs, and supporting evidence. Step Functions is designed to orchestrate state transitions and pass JSON payloads, but large payloads should be stored outside the state machine and referenced by pointer values. Using Amazon S3 for intermediate outputs is operationally efficient because the application already uses S3 for storage, and S3 provides durable, low-cost storage with simple access patterns.

ResultPath and ResultSelector allow each state to store or reshape results so that only the required reference fields (such as s3Uri, object key, metadata, trace IDs) are forwarded to subsequent states. This preserves observability because the workflow can still log trace references, correlate steps with S3 objects, and store structured metadata for debugging. It also preserves the sequential validation design, keeping the existing ReAct pattern intact while preventing failures due to oversized payloads.

Option A adds additional services and read/write patterns that increase operational complexity. Option C introduces custom compression/decompression logic that is fragile, adds latency, and complicates troubleshooting. Option D increases orchestration overhead by splitting workflows and coordinating with events, which makes debugging harder and increases failure modes.

Therefore, Option B meets the payload limit requirement while keeping the architecture simple and observable.

Option D is the best fit because it implements a reliable event-driven MLOps workflow that automates retraining and redeployment with clear orchestration, auditability, and production-grade error handling. The requirement is explicit: whenever a new file is uploaded to Amazon S3, the system must retrain and then redeploy the model used by a web application. A common AWS pattern is to use an S3 event notification to trigger an AWS Lambda function, which then starts a controlled workflow. In option D, Lambda serves as the event handler that reacts immediately to the S3 upload event and passes the necessary context (bucket, object key, dataset version) into an AWS Step Functions Standard state machine.

Step Functions Standard is appropriate for model retraining pipelines because training and deployment steps can be long-running and benefit from durable state, retries, and failure handling. It provides execution history, making it easier to troubleshoot why a particular retraining run failed and to prove which dataset version produced which model version. This operational visibility is critical when the dataset is “growing rapidly” and retraining is frequent.

Within the workflow, Amazon SageMaker Pipelines is the right service to run the ML lifecycle stages in a repeatable way: data processing (if needed), training, evaluation/quality checks, mod el registration, and deployment to an endpoint used by the application. SageMaker Pipelines is purpose-built for CI/CD-style ML, supporting automated redeployments when a new approved model artifact is produced. By calling a pipeline execution from Step Functions, the company can add governance gates (for example, only deploy if evaluation metrics meet thresholds), and can apply consistent rollback and notification steps when deployment fails.

The other options are weaker: A confuses inference with retraining and does not provide deployment orchestration. B adds unnecessary webhook complexity and describes an awkward event bus configuration. C introduces Autopilot/Data Wrangler, which may be useful but adds extra moving parts and is not required to meet the trigger-and-redeploy requirement.

Option A provides the most complete, AWS-native defense-in-depth solution for protecting against prompt injection attacks while meeting audit and resiliency requirements. Amazon Bedrock guardrails are designed specifically to enforce safety policies on both user inputs and model outputs, including protections against prompt injection and jailbreak attempts.

Setting content filters to high increases sensitivity to malicious or manipulative inputs. Guardrail profiles allow the same guardrail configuration to be applied consistently across multiple Regions, enabling cross-Region inference and failover without configuration drift. This directly satisfies the requirement for regional resilience.

Amazon CloudWatch Logs captures detailed guardrail intervention events, including when content is blocked, modified, or flagged. Custom metrics derived from these logs enable fine-grained auditing, alerting, and reporting on safety enforcement actions. This provides a more detailed audit trail of safety interventions than API-level logs alone.

Option B adds WAF protection but lacks detailed guardrail intervention logging. Option C introduces additional services and custom logic that increase complexity and may miss model-specific injection patterns. Option D references replication concepts that are not aligned with Bedrock guardrail operational models and relies on word filters, which are insufficient against sophisticated prompt injection techniques.

Therefore, Option A best meets the requirements for layered protection, auditability, and cross-Region resilience using managed Amazon Bedrock safety controls.

Option C is the correct solution because AWS AppConfig is purpose-built to manage dynamic application configurations with low latency, strong validation, and minimal operational overhead, which directly matches the company’s requirements.

AWS AppConfig enables the company to centrally manage model selection logic, inference parameters, and customer-tier routing rules without redeploying Lambda functions. By using feature flags, the company can easily perform A/B testing of new models or prompt strategies by gradually rolling out changes to a subset of users or customer tiers. This allows experimentation and controlled releases without code changes.

AppConfig also supports JSON schema validation, which is critical for validating parameters such as temperature, maximum token limits, and other model-specific settings before they are applied. This prevents invalid or unsafe configurations from being deployed and reduces the risk of runtime errors or degraded model behavior in production.

Using the AWS AppConfig Agent allows Lambda functions to retrieve configurations efficiently with built-in caching and polling mechanisms, minimizing latency and avoiding excessive calls to configuration services. This approach scales well for high-throughput, low-latency applications such as GenAI APIs behind Amazon API Gateway.

Option A introduces unnecessary redeployment logic and polling complexity. Option B requires building and maintaining custom configuration access patterns in DynamoDB and does not natively support feature flags or schema validation. Option D adds operational overhead by requiring ElastiCache cluster management and custom validation logic.

Therefore, Option C provides the most scalable, flexible, and low-maintenance solution for dynamic model switching, A/B testing, and safe configuration management in a GenAI application.

Amazon CloudWatch provides the most integrated path for unifying technical and business metrics. By importing business metrics into CloudWatch (via custom metrics or metric streams), teams can build custom dashboards that provide a single pane of glass for both system health and conversion performance. Composite alarms allow stakeholders to be notified only when multiple conditions are met (e.g., high latency and dropping conversion rates), reducing alert fatigue. Applying anomaly detection to these metrics is essential for GenAI workloads because performance baselines can shift subtly; CloudWatch can automatically detect these deviations and trigger alerts through Amazon SNS . This solution provides comprehensive correlation and automated alerting with less operational complexity than managing external visualization servers (Option B) or multi-service analytics pipelines (Option C).

Option B is the correct solution because Amazon Q Business natively supports access control lists (ACLs) for S3 data sources using a single, centralized JSON file that maps S3 prefixes to IAM Identity Center groups. This approach directly aligns with the company’s data organization model, where each department’s data is stored under a distinct S3 prefix and each employee belongs to exactly one department group.

Using a single acl.json file at the bucket root minimizes operational overhead by centralizing access control logic in one location. Administrators can update department mappings without touching individual folders or changing IAM permissions, which simplifies governance and reduces the risk of configuration drift. Amazon Q Business automatically evaluates the user’s IAM Identity Center group membership at query time and filters accessible documents accordingly.

Option A increases operational complexity by requiring a separate ACL file in every department folder, which becomes difficult to maintain as departments or prefixes change. Option C attempts to enforce access using IAM permissions sets, but Amazon Q Business access control for S3 data sources is not designed to be managed through IAM condition logic and would significantly increase complexity. Option D introduces a custom metadata structure that is not the supported mechanism for Amazon Q Business access enforcement.

Therefore, Option B provides the cleanest, most scalable, and AWS-recommended solution for enforcing department-based access control with the least operational effort.

Option B is correct because it uses the managed evaluation capability in Amazon Bedrock that is intended specifically for comparing foundation models using a consistent prompt set and producing structured results with minimal custom tooling. In a Bedrock evaluation workflow, you provide an input dataset of prompts, typically in JSON Lines format so each line represents one evaluation record. Storing the JSONL file in Amazon S3 allows Bedrock to read the dataset at scale and write standardized evaluation outputs back to S3 for downstream analysis, sharing, and retention.

The key requirement is to assess both quality and safety across multiple models. A Bedrock evaluation job can use a judge model to score the generated outputs against defined criteria. This approach supports repeatable, apples-to-apples comparisons because the same judge model and scoring rubric can be applied to every candidate foundation model. The candidate models are configured as generators, meaning each evaluation job run uses one selected FM to produce answers for the same prompt set, and the judge model evaluates those answers. That matches the requirement to generate evaluation reports that help a data scientist select the best FM.

Option A does not use Bedrock evaluation jobs, and a knowledge base plus RetrieveAndGenerate is a RAG pattern, not an evaluation framework. It would produce responses but not standardized scoring and reporting suitable for model selection. Option C is incorrect because Bedrock evaluation outputs are delivered to S3, not directly to a BI destination, and selecting the candidate FM as the evaluator conflicts with the intended pattern of using a stable judge model. Option D mis uses knowledge bases and retrieval evaluation types when the requirement is prompt-based model assessment rather than evaluating retrieval quality.

Option D is the correct solution because Amazon Bedrock Knowledge Bases natively support reranking by using Amazon-managed reranker models, which are specifically designed to improve contextual relevance after the initial vector retrieval step. This approach directly addresses the root cause of the issue: semantically similar but contextually irrelevant documents being passed to the foundation model.

By enabling the reranking configuration within Amazon Bedrock Knowledge Bases, the application can automatically reorder retrieved documents based on deeper contextual understanding, such as regulatory scope, legal applicability, and semantic intent. This significantly improves retrieval precision, which reduces hallucinations and improves the factual accuracy of generated regulatory guidance.

Option D requires no additional infrastructure, no custom orchestration logic, and no separate model hosting. The reranking is fully managed by Amazon Bedrock and integrates seamlessly with the existing RetrieveAndGenerateStream workflow. This makes it the lowest operational overhead solution.

Option A introduces operational complexity by requiring a custom SageMaker endpoint, API Gateway routing, and model lifecycle management. Option B combines multiple unrelated services and introduces significant complexity without being purpose-built for RAG relevance ranking. Option C improves relevance but requires explicitly calling the Rerank API and modifying the application pipeline, which increases operational and integration effort compared to built-in reranking.

Therefore, Option D provides the most efficient, scalable, and AWS-recommended method to improve RAG retrieval quality while minimizing operational burden.

Option A is the most appropriate design because it provides scalable multi-agent orchestration, clear domain separation, and strong governance with minimal operational complexity. A supervisor-agent pattern is a standard AWS-recommended approach for multi-agent systems: one agent performs intent classification and routing, while specialized agents handle domain-specific tasks.

Isolating data with separate knowledge bases ensures that each specialized collaborator agent retrieves only the information relevant to its department. This improves response accuracy, reduces hallucinations, and supports privacy controls because clinical content, claims content, and scheduling content can have different access policies. IAM-based filtering ensures that each agent has permission only to the knowledge base it is authorized to use.

Routing patient inquiries through a supervisor agent supports high concurrency and extensibility. New departments or features can be added by introducing new collaborator agents and knowledge bases without redesigning the entire system. Because routing is handled centrally, changes in classification logic do not require updates across many independent supervisors.

Using RAG within each collaborator agent ensures that responses are grounded in department-approved information sources, which is critical in healthcare settings to reduce unsafe or incorrect guidance. This approach also improves performance because each retrieval scope is smaller and more relevant, supporting thousands of parallel interactions.

Option B introduces manual handoffs that do not scale. Option C relies on rule-based routing inside one general agent, which becomes brittle and difficult to govern as complexity grows. Option D mixes all departments into a single knowledge base and merges responses externally, increasing risk of incorrect domain answers and operational overhead.

Therefore, Option A best meets the scalability, correctness, and multi-agent onboarding requirements.

AWS Step Functions provides native support for human-in-the-loop workflows, making it the best fit for regulatory oversight requirements. The waitForTaskToken integration pattern is explicitly designed to pause a workflow until an external actor—such as a human reviewer—completes a task.

In this architecture, AI-generated recommendations are sent to a human technician for review. The workflow pauses execution using a task token. Once the technician approves or rejects the recommendation, an AWS Lambda function calls SendTaskSuccess or SendTaskFailure, allowing the workflow to continue deterministically.

This approach ensures full auditability, as Step Functions records every state transition, timestamp, and execution path. Storing review outcomes in Amazon DynamoDB provides durable, queryable audit records required for regulatory compliance.

Option A requires custom orchestration and lacks native workflow state management. Option C incorrectly uses AWS Glue, which is not designed for approval workflows. Option D uses caching instead of durable audit storage and introduces unnecessary complexity.

Therefore, Option B is the AWS-recommended, lowest-risk, and most auditable solution for mandatory human review of AI outputs.

Option C is the correct solution because it provides near real-time monitoring, hallucination detection, and cost anomaly awareness using built-in Amazon Bedrock and Amazon CloudWatch capabilities, with minimal custom development.

By configuring Amazon Bedrock invocation logging with text output logging, the company captures detailed prompt and response data for auditing and analysis without building custom logging pipelines. This data is stored in Amazon S3, providing durable storage for compliance and retrospective investigation.

Using Amazon Bedrock guardrails with contextual grounding checks allows the application to automatically detect hallucinations by verifying whether generated summaries are grounded in the provided clinical documents. This is the AWS-recommended approach for hallucination detection in RAG and summarization workloads and avoids the need to maintain custom evaluation models or pipelines.

Creating Amazon CloudWatch anomaly detection alarms for InputTokenCount and OutputTokenCount metrics enables automatic detection of abnormal token usage patterns that often correlate with runaway prompts, inefficient summarization, or prompt injection attempts. Anomaly detection adapts dynamically to usage trends, making it more effective than static thresholds for early cost warnings.

Option A introduces batch analytics with Glue and Athena, which is not near real time and increases operational overhead. Option B requires managing evaluation jobs and Lambda-based notification logic. Option D focuses on infrastructure-level monitoring and offline dashboards rather than near real-time GenAI quality and cost signals.

Therefore, Option C best meets the requirements with the least operational effort and maintenance overhead.

Option B best meets the requirements because it provides systematic diagnosis, measurable comparison, and historical traceability of prompt performance. By placing prompts under version control and testing them against complex clinical documents, the company can consistently reproduce issues, track regressions, and compare prompt behavior using quantifiable metrics such as factual accuracy, completeness, and consistency. Automated testing ensures scalability and repeatability, while version history preserves prompt evolution over time.

Option A lacks objective metrics and does not address complex documents. Option C focuses on live traffic experimentation but does not inherently diagnose prompt inconsistencies or preserve detailed historical evaluations. Option D adds medical entity analysis but introduces unnecessary service coupling and does not provide robust prompt version history or automated comparative benchmarking. Therefore, Option B is the most complete and disciplined solution.

Option B is the optimal solution because it maximizes similarity search accuracy and performance for a small, proprietary dataset while maintaining low operational complexity. Amazon MemoryDB is a fully managed, in-memory database that provides microsecond-level latency, making it ideal for real-time RAG workloads that require fast vector similarity searches.

For small datasets with low index counts, the Hierarchical Navigable Small World (HNSW) algorithm is recommended by AWS for its high recall and accuracy. Unlike approximate methods optimized for massive datasets, HNSW excels at returning the most semantically relevant vectors with minimal loss of precision, which directly improves the quality of responses generated by the Amazon Bedrock foundation model.

Vertical scaling in MemoryDB is sufficient for this use case because the dataset size is limited. Scaling up instance size provides increased memory and compute capacity without the complexity of managing distributed indexes or sharding strategies. This simplifies operations while maintaining predictable performance.

Option A’s Flat algorithm is computationally expensive and inefficient at scale, even for moderate query volumes. Option C introduces higher latency and operational overhead by using a relational database not optimized for in-memory vector search. Option D is unsuitable because Amazon DocumentDB is not designed for high-performance vector similarity workloads and introduces unnecessary replica management complexity.

Therefore, Option B best meets the requirements for accuracy, performance, and efficient integration with an Amazon Bedrock–based RAG application.

Amazon SageMaker Serverless Inference is specifically designed for applications that experience intermittent or bursty traffic. It automatically scales compute capacity based on the number of requests and scales down to zero when there is no traffic, satisfying the requirement to optimize resource usage during low demand. To meet the 500 ms latency requirement during peak periods and avoid " cold start " delays, provisioned concurrency keeps a specified number of execution environments warm and ready to respond immediately. This provides a balance between the cost-effectiveness of serverless and the performance predictability of provisioned instances. Multi-model endpoints (Option A) can introduce " noisy neighbor " issues and latency spikes, while asynchronous inference (Option D) is intended for long-running workloads and cannot meet sub-500 ms requirements.