Runtime Circuit Breakers for AI Agent Tools with AWS AppConfig and Amazon Bedrock AgentCore

Learn how to dynamically enable or disable individual AI agent tools in production without agent redeployment.

Praveen

Published Apr 10, 2026

Last modified Apr 10, 2026

﻿
Your team has deployed an AI agent to production. A tool starts misbehaving, and the agent keeps calling it — burning LLM tokens, frustrating users, and compounding the incident. You need to disable that one tool right now, without redeploying the agent.
Runtime circuit breakers solve this by letting you disable individual agent tools instantly, without agent redeployment . This post walks you through implementing runtime circuit breakers for AI agent tools using  AWS AppConfig  and  Amazon Bedrock AgentCore . For demo purposes, we built a Telecom Billing Assistant Agent with Strands Agents SDK. In emergency scenario, within seconds an operator can pull the plug on any tool. The complete source code and deployment instructions are available in the  GitHub repository .
The problemAI agents in production present unique operational challenges:
Customer experience at risk: When a tool starts misbehaving — returning wrong data, timing out, or hitting a degraded backend — it affects every user interaction that touches it. You need a way to pull the plug on that specific tool immediately, without taking down the entire agent or disrupting the tools that still work.
Redeployment is too slow for incidents: For mission-critical applications, waiting for a CI/CD pipeline to rebuild and redeploy the agent introduces unacceptable latency. An incident that could be mitigated in seconds instead takes minutes or hours, compounding the impact.
Solution overviewThe solution uses AWS AppConfig as a feature flag to dynamically enable or disable individual agent tools at runtime. The agent checks the circuit breaker state inside each tool function at execution time — not at startup — so changes take effect immediately without restarting the agent.
﻿
 ﻿ 
How it works:
User sends a message — For example, a user asks "Analyze my fixed network bill for account ACC-12345". The User Chat UI sends this request to the Telecom Billing Assistant Agent. It is deployed on Amazon Bedrock AgentCore Runtime.
Agent sends prompt to LLM — The Telecom Billing Assistant Agent passes the user's prompt along with the tool definitions to Amazon Bedrock (Anthropic Claude Sonnet 4).
LLM reasons and selects a tool — The model reads the tool descriptions, reasons about the user's request, and autonomously decides which tool to call. In this case, it selects  fixed_network_bill_analysis  because the user asked about fixed network bills. This tool is invoked.
Tool Execution:
Admin toggle (separate flow) — By default Fixed Network Bill Tool is available for process requests. Based on the situation, admin can enable AppConfig flag circuit_breaker.enabled  flag. It takes effect immediately.
Circuit breaker check (only for Fixed Network Tool):
Fixed Network Bill Tool is selected → first calls  get_circuit_breaker_status()  which reads from AWS AppConfig.
If AppConfig returns  enabled: true  → tool returns a  SERVICE_UNAVAILABLE , agent tells user the service is temporarily down. You can publish any customised message. 
If AppConfig returns  enabled: false  → tool runs  analyze_fixed_network_bill()  normally.
If AppConfig is unreachable → defaults to enabled (fail-closed, safe mode).
Response — Agent sends the result back through Agent to the User Chat UI.
AWS services usedBefore diving into the implementation, here's a brief AWS services overview used in this solution:
 Amazon Bedrock  provides access to foundation models (Anthropic Claude Sonnet 4 in this demo) through a unified API. The Strands Agent uses Bedrock for LLM inference — reasoning about user requests and deciding which tools to call.
 Amazon Bedrock AgentCore Runtime  Amazon Bedrock AgentCore Runtime provides a secure, serverless and purpose-built hosting environment for deploying and running AI agents or tools.
 AWS AppConfig  AWS AppConfig feature flags and dynamic configurations help software builders quickly and securely adjust application behavior in production environments without full code deployments. AWS AppConfig speeds up software release frequency, improves application resiliency, and helps you address emergent issues more quickly. 
 Strands Agents SDK  is an open-source SDK for building AI agents with a model-driven approach. 
Implementation detailsCircuit breaker check at tool execution timeThe circuit breaker is checked inside the tool function, not at agent startup. This is the key design decision:
@tool
def fixed_network_bill_analysis(account_id: str, months: int = 3) -> str:
    # Check circuit breaker at execution time
    if get_circuit_breaker_status():
        return json.dumps({
            "error": "SERVICE_UNAVAILABLE",
            "message": "Fixed network bill analysis is temporarily unavailable.",
            "suggestion": "Please try again later or use mobile bill analysis."
        })
    # Proceed with normal analysis
    return json.dumps(analyze_fixed_network_bill(account_id, months))
Structured error responsesWhen a tool is blocked, it returns a structured JSON error instead of raising an exception. The LLM interprets this structure and responds conversationally — turning a hard operational control into a smooth user experience. The agent might say: "Fixed network analysis is temporarily unavailable. I can help with your mobile bill in the meantime."
Fail-closed safetyIf AppConfig is unreachable (network issue, misconfiguration, etc.), the circuit breaker defaults to enabled — the tool is blocked. This is a deliberate design choice: when you can't verify the state of the world, the safe default is to restrict, not to allow.
AppConfig configurationThe circuit breaker is controlled via a simple JSON configuration:
{
  "circuit_breaker": {
    "enabled": false
  }
}
Set  enabled: true  to disable the fixed network bill tool. Set  enabled: false  to re-enable all tools.
Follow the steps below to deploy the circuit breaker infrastructure, launch the agent, and test the pattern end-to-end in your own AWS account.
PrerequisitesAn  AWS account 
 AWS CLI v2.32.0+  installed
 Python 3.10+ 
 Amazon Bedrock model access  enabled for Claude Sonnet 4 in your region
IAM permissions for:
 bedrock:InvokeModel  and  bedrock:ConverseStream 
 appconfig:*  and  appconfigdata:* 
First-time AWS setupIf you have not configured AWS CLI credentials yet, the simplest approach is the   aws login   command, which authenticates using your existing AWS Management Console credentials:
# Login (opens browser for authentication)
aws login
﻿
# Verify you are in the right account
aws sts get-caller-identity
This generates temporary credentials. If you prefer a named profile:
aws login --profile my-account
export AWS_PROFILE=my-account
Note:  aws login  requires AWS CLI v2.32.0+. If you use IAM Identity Center (SSO), use  aws configure sso  and  aws sso login  instead. See the  AWS CLI authentication docs  for all options.
DeploymentStep 1: Clone the repository and set up the environment
git clone https://github.com/aws-samples/sample-agent-tool-circuit-breaker.git
cd sample-agent-tool-circuit-breaker
﻿
python3 -m venv .venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate
pip install -r requirements.txt
pip install -r src/frontend/requirements.txt
pip install bedrock-agentcore-starter-toolkit
Step 2: Deploy AppConfig infrastructureDeploy the CloudFormation stack to create AppConfig resources:
aws cloudformation deploy \
  --template-file cloudformation/circuit-breaker-stack.yaml \
  --stack-name circuit-breaker-agent \
  --region us-east-1
This creates the AppConfig application, environment, configuration profile, and deploys the initial circuit breaker configuration (disabled — all tools available).
Verify the deployment:
aws cloudformation describe-stacks \
  --stack-name circuit-breaker-agent \
  --query 'Stacks[0].Outputs' \
  --output table
Step 3: Deploy the agent to AgentCore RuntimeConfigure the agent:
agentcore configure -e src/sample_agent.py
When prompted, use these values:
Prompt
Value
Agent name
Press Enter (default: sample_agent)
Region
us-east-1
Auto-create execution role
Press Enter
Auto-create ECR
Press Enter
Dependency file
Press Enter (auto-detected requirements.txt)
Configure OAuth authorizer
no (press Enter)
Configure request header allowlist
no (press Enter)
Launch the agent:
agentcore launch
This builds a container image and deploys it to AgentCore Runtime. It may take several minutes. Note the Agent ARN from the output.
Step 4: Add AppConfig permissions to the agent roleThe auto-created execution role needs AppConfig permissions so the agent can read the circuit breaker flag. Find the role name in  .bedrock_agentcore.yaml  under  execution_role  — it will look like  AmazonBedrockAgentCoreSDKRuntime-us-east-1-xxxxxxxxxx .
Go to the  IAM Console , search for that role, and attach an inline policy with these permissions:
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "appconfig:GetLatestConfiguration",
        "appconfig:StartConfigurationSession",
        "appconfig:GetApplication",
        "appconfig:ListApplications",
        "appconfig:GetEnvironment",
        "appconfig:ListEnvironments",
        "appconfig:GetConfigurationProfile",
        "appconfig:ListConfigurationProfiles",
        "appconfig:CreateHostedConfigurationVersion",
        "appconfig:StartDeployment",
        "appconfig:GetDeployment"
      ],
      "Resource": "*"
    }
  ]
}
Give the inline policy a name and click Create Policy.
Important: Without this step, the agent cannot read AppConfig and will default to fail-closed mode (circuit breaker enabled, fixed network tool disabled).
Note: This policy uses  "Resource": "*"  for simplicity. For production, scope resources to your specific AppConfig ARNs following the principle of least privilege. 
Step 5: Start the Streamlit frontendsEach frontend needs its own terminal. In each new terminal, activate the virtual environment and set environment variables:
cd sample-agent-tool-circuit-breaker
source .venv/bin/activate
export AWS_REGION=us-east-1
export AGENT_ARN=<agent-arn-from-step-3>
Start the User Chat UI (Terminal 2):
streamlit run src/frontend/app.py
Start the Admin Dashboard (Terminal 3):
streamlit run src/frontend/admin_app.py --server.port 8502
User View ( http://localhost:8501 ): Chat with the billing agent, see available services
Admin View ( http://localhost:8502 ): Toggle the circuit breaker on/off with a single click
Step 6: Test the circuit breakerWith both frontends running, verify the circuit breaker works end-to-end:
6a. Test with circuit breaker disabled (default)
Open the User Chat UI and ask:
"Analyze my mobile bill for account ACC-12345"
"Analyze my fixed network bill for account ACC-12345"
Both should return analysis results. The Admin Dashboard should show both tools as available.
6b. Enable the circuit breaker
Either click "ENABLE CIRCUIT BREAKER" in the Admin Dashboard, or run in a terminal:
python scripts/toggle_circuit_breaker.py --enable
The Admin Dashboard will show:
🌐 Fixed Network Analysis
⚠️ Temporarily Unavailable
6c. Test with circuit breaker enabled
Refresh the Chat UI and ask "Analyze my fixed network bill for account ACC-12345". The agent will respond gracefully:
"It looks like the fixed network bill analysis service is currently unavailable due to maintenance. I can still help with your mobile bill analysis. You may want to try the fixed network analysis again later when the service is restored."
The agent doesn't crash or return a raw error — it interprets the structured  SERVICE_UNAVAILABLE  response and communicates naturally to the user, suggesting alternatives.
Note: This sample code is intended for demonstration purposes only. It illustrates the runtime circuit breaker pattern for AI agent tools. For production deployments, additional considerations such as scoped IAM policies, monitoring, error handling, and security hardening may be required based on your specific use case.
Extending the patternThis pattern can be adapted for many production scenarios:
Industry
Agent Use Case
Circuit Breaker Application
Financial Services
Trading assistant
Disable trade execution during market volatility
Healthcare
Clinical decision support
Disable drug interaction tool during formulary updates
E-commerce
Shopping concierge
Disable inventory lookup during warehouse migration
SRE/DevOps
Incident response agent
Disable auto-remediation during change freeze windows
Best practicesCircuit breaker design:
Default to fail-closed (tool disabled) when the configuration source is unreachable.
Use structured error responses so the agent can communicate gracefully to users.
Check the circuit breaker at tool execution time, not at agent startup, to allow real-time control.
AppConfig operations:
Store your circuit breaker configuration in version control alongside the agent code.
Use the  AllAtOnce  with zero Bake time deployment strategy for instant propagation during incidents.
Set up CloudWatch alarms on AppConfig deployment failures.
Project structure
sample-agent-tool-circuit-breaker/
├── cloudformation/
│   └── circuit-breaker-stack.yaml   # AppConfig + IAM infrastructure
├── src/
│   ├── sample_agent.py              # Main agent with AppConfig integration
│   ├── tools.py                     # Bill analysis tool implementations
│   └── frontend/
│       ├── app.py                   # User chat interface (Streamlit)
│       ├── admin_app.py             # Admin dashboard (Streamlit)
│       └── requirements.txt         # Frontend dependencies
├── scripts/
│   ├── toggle_circuit_breaker.py    # CLI to toggle the circuit breaker
│   └── deploy_agent.py             # AgentCore deployment script
├── tests/
│   └── test_agent.py                # Test suite
├── requirements.txt                 # Python dependencies
├── Dockerfile                       # Container image for AgentCore deployment
├── deploy.sh                        # Quick setup script
├── CONTRIBUTING.md
├── LICENSE
└── README.md
CleanupTo remove all resources created by this demo:
aws cloudformation delete-stack --stack-name circuit-breaker-agent
aws cloudformation wait stack-delete-complete --stack-name circuit-breaker-agent
This deletes the AppConfig application, environment, configuration profile, and IAM role in one command.
ConclusionRuntime circuit breakers give operations teams the control they need over AI agents in production. By combining AWS AppConfig with the Strands Agents SDK and Amazon Bedrock AgentCore, organizations can dynamically enable or disable individual agent tools in seconds — without redeployment, without restarts, and without disrupting the tools that are still working.
For more information about building AI agents on AWS, see the  Strands Agents SDK  and  Amazon Bedrock AgentCore documentation .
﻿

Prompt	Value
Agent name	Press Enter (default: sample_agent)
Region	us-east-1
Auto-create execution role	Press Enter
Auto-create ECR	Press Enter
Dependency file	Press Enter (auto-detected requirements.txt)
Configure OAuth authorizer	no (press Enter)
Configure request header allowlist	no (press Enter)

Industry	Agent Use Case	Circuit Breaker Application
Financial Services	Trading assistant	Disable trade execution during market volatility
Healthcare	Clinical decision support	Disable drug interaction tool during formulary updates
E-commerce	Shopping concierge	Disable inventory lookup during warehouse migration
SRE/DevOps	Incident response agent	Disable auto-remediation during change freeze windows

# agents # amazon-bedrock-agentcore

Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.

Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article

Builder Center

Runtime Circuit Breakers for AI Agent Tools with AWS AppConfig and Amazon Bedrock AgentCore

Praveen

﻿

The problem

Solution overview

AWS services used

Implementation details

Circuit breaker check at tool execution time

Structured error responses

Fail-closed safety

AppConfig configuration

Prerequisites

First-time AWS setup

Deployment

Step 1: Clone the repository and set up the environment

Step 2: Deploy AppConfig infrastructure

Step 3: Deploy the agent to AgentCore Runtime

Step 4: Add AppConfig permissions to the agent role

Step 5: Start the Streamlit frontends

Step 6: Test the circuit breaker

Extending the pattern

Best practices

Project structure

Cleanup

Conclusion

﻿