AWS Bedrock Operations 2026

<!--
# COPYRIGHT NOTICE
# This file is part of the "Universal AI Agentic Skills" project.
# Copyright (c) 2026 MD BABU MIA, PhD <md.babu.mia@mssm.edu>
# All Rights Reserved.
#
# This code is proprietary and confidential.
# Unauthorized copying of this file, via any medium is strictly prohibited.
#
# Provenance: Authenticated by MD BABU MIA

-->

---
name: aws-bedrock-operations-2026
description: Build and run production workloads on Amazon Bedrock with current model access, IAM controls, and reliability guardrails. Use when implementing Bedrock inference pipelines, agent workflows, or model upgrades.
measurable_outcome: Execute skill workflow successfully with valid output within 15 minutes.
allowed-tools:
  - read_file
  - run_shell_command
---

# AWS Bedrock Operations (2026)

## Core Capabilities

- Use the 2026-05-04 `aws-samples/sample-strands-agent-with-agentcore` TypeScript reference architecture as an implementation example for Bedrock-backed agentic chatbots: map Strands Agents orchestration to Amazon Bedrock AgentCore, define MCP and A2A integration contracts, constrain browser automation permissions, scope IAM per agent and tool, and add production guardrails before adapting the sample.
- Use the 2026-05-04 `aws-samples/sample-strands-agent-with-agentcore` TypeScript reference architecture for Strands Agents plus Amazon Bedrock AgentCore chatbots: document A2A and MCP interoperability, browser automation and voice-agent components, least-privilege IAM boundaries, and Bedrock Guardrails placement before adapting the sample.
- Use `aws-samples/sample-strands-agent-with-agentcore` as an illustrative TypeScript reference architecture for Strands Agents plus Amazon Bedrock AgentCore chatbots: map A2A and MCP integration contracts, browser or voice assistant surfaces, least-privilege IAM boundaries, deployment topology, and the hardening gaps that must be closed before treating sample code as production-ready.
- Use the 2026-05-04 `aws-samples/sample-strands-agent-with-agentcore` reference architecture as an implementation pattern for managed Strands Agents deployment on Amazon Bedrock AgentCore, covering A2A/MCP interoperability, browser automation and voice assistant components, least-privilege IAM boundaries, observability paths, and production guardrails before adapting the TypeScript sample.
- Apply the 2026-05-04 `aws-samples/sample-strands-agent-with-agentcore` TypeScript reference architecture as an implementation pattern for agentic chatbots with Strands Agents and Amazon Bedrock AgentCore: define AgentCore deployment boundaries, MCP and A2A integration contracts, browser automation and voice-assistant surfaces, least-privilege IAM boundaries, and production guardrails before adapting the sample.
- Add a Strands Agents plus Amazon Bedrock AgentCore reference architecture review for Bedrock-hosted agent workflows: verify MCP integration contracts, agent-to-agent handoff patterns, browser automation boundaries, least-privilege IAM scoping, and production deployment checks before adapting `aws-samples/sample-strands-agent-with-agentcore`.
- Use the 2026-05-04 `aws-samples/sample-strands-agent-with-agentcore` TypeScript reference architecture as a managed agent chatbot implementation pattern: map Strands Agents orchestration onto Amazon Bedrock AgentCore, verify MCP tool contracts, isolate browser automation and voice assistant paths, define least-privilege IAM boundaries, and document deployment guardrails before adapting the sample.
- Use the 2026-05-04 `aws-samples/sample-strands-agent-with-agentcore` TypeScript reference architecture as an implementation pattern for agentic chatbots with Strands Agents and Amazon Bedrock AgentCore: map A2A and MCP integration, browser and voice tools, IAM boundaries, deployment topology, observability paths, and Bedrock Guardrails controls before adapting the sample.
- Use `aws-samples/sample-strands-agent-with-agentcore` as a Strands Agents plus Amazon Bedrock AgentCore reference architecture for chatbot and multi-agent deployments: document MCP integration, browser automation boundaries, least-privilege IAM roles, observability paths, and production-hardening requirements before adapting the TypeScript sample.
- Use the 2026-05-04 `aws-samples/sample-strands-agent-with-agentcore` TypeScript reference architecture as an implementation example for agentic chatbot deployment with Strands Agents and Amazon Bedrock AgentCore, covering A2A/MCP integration, browser automation, voice assistant surfaces, IAM boundaries, and production guardrails before adapting it.
- Use `aws-samples/sample-strands-agent-with-agentcore` as a non-production reference pattern for Strands Agents on Amazon Bedrock AgentCore: define AgentCore deployment boundaries, MCP and A2A integration points, browser automation and voice assistant tool safety controls, least-privilege IAM scoping, and the hardening work required before adapting the sample architecture for production.
- Use the 2026-05-04 `aws-samples/sample-strands-agent-with-agentcore` reference architecture as an AgentCore and Strands Agents planning note: define Bedrock AgentCore deployment boundaries, MCP and A2A interoperability contracts, browser automation permissions, voice-assistant surfaces, least-privilege IAM scoping, and production guardrails before adapting the TypeScript chatbot sample.
- Use the 2026-05-04 `aws-samples/sample-strands-agent-with-agentcore` reference architecture as an implementation pattern for Strands Agents plus Amazon Bedrock AgentCore agentic chatbots: evaluate MCP tool wiring, A2A handoffs, browser automation, voice assistant channels, least-privilege IAM, Bedrock Guardrails, deployment topology, and observability checks before adapting the TypeScript sample.
- Use the 2026-05-04 `aws-samples/sample-strands-agent-with-agentcore` TypeScript repo as an architecture reference for Strands Agents plus Amazon Bedrock AgentCore agentic chatbots: map MCP tool integration, A2A/agent-to-agent handoffs, voice and browser automation boundaries, IAM and deployment guardrails, and the sample-to-production gaps before reusing any sample implementation choices.
- Use `aws-samples/sample-strands-agent-with-agentcore` as a reference architecture for Strands Agents chatbots on Amazon Bedrock AgentCore: document AgentCore hosting responsibilities, MCP and A2A integration contracts, voice and browser automation boundaries, least-privilege IAM, deployment topology, and production guardrails before adapting the TypeScript sample.
- Use the `aws-samples/sample-strands-agent-with-agentcore` reference architecture for Strands Agents plus Amazon Bedrock AgentCore agentic chatbots by documenting AgentCore deployment boundaries, A2A and MCP interoperability contracts, browser automation and voice-assistant tool boundaries, IAM and Bedrock Guardrails setup, and production readiness checks before adapting the TypeScript sample.
- Treat the 2026-05-04 `aws-samples/sample-strands-agent-with-agentcore` TypeScript repository as a reference architecture pattern for Strands Agents on Amazon Bedrock AgentCore: document MCP and A2A integration points, browser automation boundaries, voice-assistant surfaces, least-privilege IAM boundaries, and production deployment checklist items before adapting the sample.
- Use the 2026-05-04 `aws-samples/sample-strands-agent-with-agentcore` TypeScript sample as a Strands Agents plus Amazon Bedrock AgentCore reference architecture for agentic chatbots: document agent-to-agent contracts, MCP tool integration, browser automation and voice/chat channel boundaries, least-privilege IAM roles, deployment checks, and production guardrails before adapting the sample.
- Use `aws-samples/sample-strands-agent-with-agentcore` as the implementation pattern for managed agent chatbots on Strands Agents plus Amazon Bedrock AgentCore: verify MCP tool contracts, A2A agent-to-agent flows, browser automation and voice assistant surfaces, least-privilege IAM boundaries, AgentCore and Bedrock deployment topology, and pre-deployment checks before adapting the TypeScript sample.
- Use the 2026-05-04 TypeScript `aws-samples/sample-strands-agent-with-agentcore` repo as a Strands Agents plus Amazon Bedrock AgentCore reference architecture for agentic chatbots: map MCP integration, A2A-style agent communication, browser automation, voice assistant patterns, IAM responsibility boundaries, and deployment topology; record sample-repo caveats and verify production hardening assumptions before reuse.
- Use the 2026-05-04 `aws-samples/sample-strands-agent-with-agentcore` TypeScript reference architecture as an implementation pattern for agentic chatbots: keep the service layout explicit across chat entrypoints, Strands agent orchestration, AgentCore runtime binding, Bedrock access, and tool adapters; map MCP, browser automation, and voice integrations; define IAM and runtime isolation boundaries; document deployment topology; and complete a production review checklist for observability, tests, guardrails, approvals, rollback, limits, and security before rollout.
- Use the `aws-samples/sample-strands-agent-with-agentcore` TypeScript reference architecture to plan agentic Bedrock chatbots with Strands Agents and Amazon Bedrock AgentCore: map MCP and A2A contracts, browser automation or voice-assistant tool boundaries, least-privilege IAM isolation for agents and tools, deployment topology across ingress, Strands code, AgentCore runtime, Bedrock access, and integrations, and production guardrails for observability, approval, rollback, tests, limits, and security review before adapting the sample.
- Use the 2026-05-04 `aws-samples/sample-strands-agent-with-agentcore` reference architecture to scope Bedrock agentic chatbot designs that combine Strands Agents with Bedrock AgentCore: capture MCP and A2A integration points, browser automation and voice-assistant patterns, least-privilege IAM boundaries, deployment topology, and the decision criteria for choosing managed AgentCore hosting instead of custom orchestration.
- Use the `aws-samples/sample-strands-agent-with-agentcore` reference architecture when designing Strands Agents on Amazon Bedrock AgentCore for agentic chatbots: document MCP/tool wiring, A2A handoff patterns, voice assistant and browser automation boundaries, IAM and Bedrock Guardrails controls, and deployment checks before adapting the TypeScript sample.
- Use the official `aws-samples/sample-strands-agent-with-agentcore` Strands Agents plus Amazon Bedrock AgentCore reference architecture to evaluate MCP and A2A integration, AgentCore runtime identity and memory boundaries, browser and voice tools, deployment boundaries, observability, and authorization; explicitly distinguish sample defaults from production requirements for least privilege, isolation, durable memory governance, approval controls, resilience, and operational hardening.
- Use `aws-samples/sample-strands-agent-with-agentcore` as a Strands Agents plus Amazon Bedrock AgentCore reference architecture for MCP and A2A integration; map browser and voice tool permissions, identity and trust boundaries, deployment topology, end-to-end tracing, approval gates for consequential actions, and production-hardening requirements before adapting the sample.
- Apply the `aws-samples/sample-strands-agent-with-agentcore` reference architecture to Strands Agents and Bedrock AgentCore runtime deployment by defining identity and least-privilege IAM, MCP and A2A integration boundaries, browser and voice tool controls, session-state ownership, observability, deployment topology, and production-hardening requirements before adapting the sample.
- Use `aws-samples/sample-strands-agent-with-agentcore` as a Strands Agents plus Amazon Bedrock AgentCore reference architecture for MCP and A2A integration and browser and voice tools; explicitly review identity and least-privilege IAM boundaries, deployment topology, observability, per-session isolation, and production-hardening gaps before adapting the sample.
- Review the Strands Agents and Amazon Bedrock AgentCore reference architecture for MCP and A2A integration, browser automation and voice tools, explicit identity boundaries, end-to-end observability, deployment topology, and production hardening requirements.
- Validate Strands Agents plus Amazon Bedrock AgentCore reference architectures for multimodal or voice-enabled agents against explicit identity and session-state ownership, MCP and A2A trust boundaries, isolated browser automation, end-to-end observability, documented deployment topology, and least-privilege controls, using `aws-samples/sample-strands-agent-with-agentcore` as the implementation reference.
- Use the 2026-05-04 `aws-samples/sample-strands-agent-with-agentcore` TypeScript reference architecture as an implementation example for AWS-native agentic chatbots with Strands Agents and Amazon Bedrock AgentCore; map Strands agent orchestration, Bedrock AgentCore deployment/runtime, MCP integration, agent-to-agent (A2A) protocol use, browser automation and voice assistant patterns, identity and session boundaries, least-privilege IAM, TypeScript deployment topology, production observability checks, and production guardrails before adapting it.
- Adapt the Strands Agents on Bedrock AgentCore sample by defining MCP and A2A trust boundaries, workload identity and least-privilege IAM, isolated browser and voice tool runtimes, observable agent and tool paths, explicit session-state ownership and retention, deployment and rollback topology, human approval gates for consequential actions, and production hardening before deployment.
- Evaluate `aws-samples/sample-strands-agent-with-agentcore` as a production adaptation baseline by documenting deployment boundaries, workload and user identity with least-privilege IAM, MCP and A2A interfaces, browser and voice tool isolation, session-state ownership and lifecycle, observability, human approval gates, and remaining hardening gaps before rollout.
- Use `aws-samples/sample-strands-agent-with-agentcore` as an implementation pattern for TypeScript deployments while treating production controls as adaptation work: define AgentCore workload identity, session isolation, and memory ownership and retention boundaries; constrain MCP, A2A, browser, and voice interfaces; add end-to-end observability; provision infrastructure as code with least-privilege IAM; and document testing, resilience, approval, rollback, and other production-hardening requirements before rollout.
- Use the `aws-samples/sample-strands-agent-with-agentcore` AgentCore reference architecture for Strands Agents on Bedrock to plan MCP integration contracts, A2A handoff boundaries, browser automation and voice assistant interfaces, TypeScript deployment units, least-privilege IAM, and the decision point for managed AgentCore versus custom orchestration.
- Build a production-readiness checklist from the Strands Agents on Bedrock AgentCore reference architecture that covers MCP and A2A trust boundaries, browser and voice tool permissions, workload and user identity separation, observable agent and tool paths, deployment topology and rollback units, and unresolved hardening requirements before release.
- Prefer managed AWS agent infrastructure with Bedrock AgentCore hosting for Strands Agents when the workload fits the sample's managed runtime, IAM, guardrail, MCP/A2A, browser, voice assistant, and deployment boundaries; prefer self-hosted runtimes only when custom routing, isolation, deployment, or control-plane requirements are explicit and documented.
- Use the 2026-05-04 TypeScript `aws-samples/sample-strands-agent-with-agentcore` repository as the Strands Agents plus Bedrock AgentCore reference architecture for chatbot deployment: define deployment boundaries, MCP and A2A interfaces, browser and voice tool surfaces, least-privilege IAM, observability, and production guardrails before adapting it.
- Use the 2026-05-04 `aws-samples/sample-strands-agent-with-agentcore` reference architecture to evaluate AgentCore deployment shape, Strands Agents orchestration, Bedrock access, A2A and MCP interoperability, browser automation and voice-assistant tool boundaries, IAM controls, and production-readiness checks before adapting agentic chatbot implementations.
- Use the 2026-05-04 `aws-samples/sample-strands-agent-with-agentcore` TypeScript sample as a managed Strands Agents plus Bedrock AgentCore chatbot reference pattern: document AgentCore deployment ownership, MCP and A2A interoperability contracts, browser and voice assistant surfaces, IAM trust boundaries, observability paths, and production readiness checks before adapting it for AWS-hosted agents.
- Use `aws-samples/sample-strands-agent-with-agentcore` as a reference architecture note for AWS sample-derived chatbot stacks with Strands Agents and Amazon Bedrock AgentCore: map agent-to-agent and MCP integration contracts, browser automation and voice assistant patterns, least-privilege IAM boundaries, and deployment checks before adapting the TypeScript sample.

## Strands Agents + Bedrock AgentCore Reference Architecture

- Treat the sample as a TypeScript chatbot deployment reference: keep chat or channel entrypoints, Strands agent orchestration, AgentCore hosting/runtime binding, Bedrock access, and tool adapters as explicit boundaries.
- Review MCP tool contracts and A2A handoff paths before adding tools, multi-agent routing, browser automation, or voice assistant channels.
- For browser automation or voice assistant tools, document the invocation path, permission boundary, and channel-specific failure handling before enabling them in an agent flow.
- Keep browser automation and voice assistant patterns behind explicit permission, network, and channel-handling boundaries.
- Define least-privilege IAM boundaries for each agent, tool, browser automation path, and channel surface before deployment.
- Document the deployment topology across chatbot ingress, Strands agent code, AgentCore runtime, Bedrock model access, MCP/browser/voice integrations, logs, metrics, and rollback units.
- Use AgentCore when the workload should follow the reference architecture's hosted agent runtime pattern; use custom orchestration when existing routing, deployment, or control-plane requirements make that hosted topology a poor fit, and document the decision before implementation.
- Add observability hooks for inference calls, agent handoffs, MCP tool calls, browser automation steps, voice assistant flows, errors, retries, and throttling.
- Production checklist: confirm regional model availability, service limits, guardrails, tests, evaluation gates, security review, operational runbooks, and rollback criteria before treating the TypeScript sample architecture as deployable.

## Workflow

1. Confirm regional model availability, access grants, and service limits from `references/sources.md`.
2. Choose the Bedrock path that matches the workload: Converse API, Agents, Knowledge Bases, Guardrails, or batch evaluation.
3. Implement IAM, secret handling, and network boundaries before application logic.
4. Define retries, throttling backoff, timeout budgets, and observability around every inference call.
5. Validate with a small canary run before broader rollout and record rollback triggers.

## Output Requirements

- State the selected Bedrock model or service path and why.
- State the IAM and network pattern being used.
- Include one operational guardrail for reliability or cost control.

## References

- https://github.com/aws-samples/sample-strands-agent-with-agentcore
- https://github.com/aws-samples/sample-strands-agent-with-agentcore
- https://github.com/aws-samples/sample-strands-agent-with-agentcore
- https://github.com/aws-samples/sample-strands-agent-with-agentcore
- https://github.com/aws-samples/sample-strands-agent-with-agentcore
- https://github.com/aws-samples/sample-strands-agent-with-agentcore
- https://github.com/aws-samples/sample-strands-agent-with-agentcore
- https://github.com/aws-samples/sample-strands-agent-with-agentcore
- https://github.com/aws-samples/sample-strands-agent-with-agentcore
- https://github.com/aws-samples/sample-strands-agent-with-agentcore
- https://github.com/aws-samples/sample-strands-agent-with-agentcore
- https://github.com/aws-samples/sample-strands-agent-with-agentcore
- https://github.com/aws-samples/sample-strands-agent-with-agentcore
- https://github.com/aws-samples/sample-strands-agent-with-agentcore
- https://github.com/aws-samples/sample-strands-agent-with-agentcore


<!-- AUTHOR_SIGNATURE: 9a7f3c2e-MD-BABU-MIA-2026-MSSM-SECURE -->