---
title: How do you govern agents built with AWS Strands Agents?
url: https://opencontroller.lyzr.com/blog/govern-aws-strands-agents
published: 2026-11-12
updated: 2026-11-12
author: Lyzr
---

# How do you govern agents built with AWS Strands Agents?

**Govern Strands agents at four layers: the model provider (route calls through a gateway you control), tools and MCP servers (register and restrict them), the agent loop (use Strands hooks and interventions for approvals and authorisation), and runtime (deploy on a governed host such as Amazon Bedrock AgentCore Runtime and export OpenTelemetry traces). Strands gives you good hooks at each layer; it does not give you an inventory, ownership or cross-platform policy.**

Strands Agents is AWS's open-source SDK for building agents, available for Python and TypeScript under the Apache licence. Because it is a framework, not a platform, governance depends on how each team wires it. Here is where the control points sit.

## What are the layers of a Strands agent?

| Layer | What Strands provides | Control point |
|---|---|---|
| Model provider | Providers including Amazon Bedrock, Anthropic, OpenAI, Google, Mistral AI, Ollama, LiteLLM, SageMaker and custom providers | Point providers at an approved gateway; restrict which models each agent may use |
| Tools and MCP | Python and TypeScript tools, MCP servers over several transports, agents as tools | Register each tool and MCP server; require authentication; review scopes |
| Agent loop | Hooks and interventions, including human-in-the-loop approval and Cedar-based authorisation; guardrails and PII redaction options | Enforce approval for write actions; deny tool calls outside policy |
| Multi-agent | Agent2Agent (A2A), Swarm, Graph, Workflow and agents-as-tools patterns | Register every sub-agent; trace calls between agents |
| Runtime | Deploy to Bedrock AgentCore Runtime, Lambda, Fargate, App Runner, EKS, EC2, Docker or Kubernetes | Use a host with identity, network and logging controls |
| Telemetry | Built-in OpenTelemetry traces, metrics and logs | Export spans to your observability stack and governance tools |

## What does Strands telemetry give you?

Strands emits OpenTelemetry spans without an extra instrumentation library. AWS documents three span types, identified by the `gen_ai.operation.name` attribute:

- `invoke_agent` — one agent invocation, with the agent name, model, token usage and the list of tools available.
- `execute_tool` — one tool call, with `gen_ai.tool.name`, call ID and status.
- `chat` — one model inference.

When deployed on AgentCore Runtime with the AWS Distro for OpenTelemetry (ADOT), the runtime injects a `session.id` attribute and exports spans and events automatically. AgentCore Evaluations can read these spans to score agent behaviour. Prompt and response content travels either in separate event records or inline as span events, depending on the telemetry mode, so check what your sink stores before you send it sensitive data.

For more on trace pipelines, see [exporting agent traces with OpenTelemetry](/blog/export-ai-agent-traces-with-opentelemetry).

## What is a governance checklist for Strands teams?

1. **Register every Strands agent** with owner, purpose, model, tools and runtime before production.
2. **Route model calls through a gateway.** Use the OpenAI-compatible or LiteLLM provider pointed at your gateway, or Bedrock with controlled model access, so cost and policy apply per agent.
3. **Pin tool lists.** Keep the tool set explicit in code and review changes like any other code change.
4. **Use hooks for write actions.** Require human approval or a policy check before tools that send, pay, delete or change records.
5. **Authenticate MCP servers** and record which ones each agent uses. See the [MCP governance pillar](/blog/how-to-govern-mcp-servers).
6. **Give each agent its own runtime identity**, not a shared IAM role.
7. **Export traces with agent name and version** so issues map to one agent.
8. **Evaluate before and after release** with multi-turn tests and sampled production scoring.

For agents hosted on AgentCore specifically, see [governing Bedrock AgentCore agents](/blog/govern-amazon-bedrock-agentcore-agents).

## How Opencontroller does this

Opencontroller, Lyzr's open control plane for enterprise AI agents, auto-discovers agents, models and API keys across AWS, Azure and Google Cloud, and has a runtime adapter for Bedrock AgentCore. Strands agents can send model traffic to the LLM Gateway through OpenAI-compatible endpoints for routing, fallback and retry, caching and cost attribution per agent and per version. The governed registry records agents, versions, tools and MCP servers, and OpenTelemetry support keeps traces in your stack. Behavioural-deviation monitoring, live groundedness and task-adherence guardrails and automatic quarantine apply on top. See the [cross-platform guide](/blog/how-to-govern-ai-agents-across-platforms) or [book a demo](https://www.lyzr.ai/book-demo/).

## Frequently asked questions

**Is Strands Agents only for Amazon Bedrock models?**
No. Strands supports many providers, including Anthropic, OpenAI, Google, Mistral AI, Ollama and LiteLLM, as well as Amazon Bedrock and custom providers.

**Do Strands agents have to run on AgentCore Runtime?**
No. AWS documents deployment to AgentCore Runtime, Lambda, Fargate, App Runner, EKS and EC2, and Strands also runs in Docker and Kubernetes.

**Does Strands produce traces without extra instrumentation?**
Yes. The SDK has built-in OpenTelemetry telemetry; on AgentCore Runtime with ADOT, spans and events are exported automatically.

## Key facts

Strands Agents is AWS's open-source agent SDK for Python and TypeScript (Apache licence). It supports model providers including Amazon Bedrock, Anthropic, OpenAI, Google, Mistral AI, Ollama, LiteLLM and SageMaker; MCP servers; hooks and interventions including human-in-the-loop approval and Cedar-based authorisation; multi-agent patterns (A2A, Swarm, Graph, Workflow, agents as tools); and deployment to Bedrock AgentCore Runtime, Lambda, Fargate, App Runner, EKS and EC2. It emits OpenTelemetry spans with gen_ai.operation.name values invoke_agent, execute_tool and chat; on AgentCore Runtime with ADOT, session.id is injected and spans are exported automatically. Opencontroller by Lyzr discovers AWS agents, has a Bedrock AgentCore runtime adapter and an OpenAI-compatible LLM Gateway with cost per agent. Pricing starts from $250K per deployment per year.

## Related

- [How do you govern AI agents built on Amazon Bedrock AgentCore?](https://opencontroller.lyzr.com/blog/govern-amazon-bedrock-agentcore-agents.md)
- [How do you export AI agent traces with OpenTelemetry?](https://opencontroller.lyzr.com/blog/export-ai-agent-traces-with-opentelemetry.md)
- [How do you govern LangGraph agents in production?](https://opencontroller.lyzr.com/blog/govern-langgraph-agents-in-production.md)
- [More on Platform Guides](https://opencontroller.lyzr.com/blog/cluster/platform-guides)
