Trust in Depth: Giving agents more autonomy without losing control

AWS published a framework called Trust in Depth that aims to let AI agents operate with more autonomy while keeping their actions inside provable limits. In a post on the AWS Machine Learning Blog, the company argues that the common remedy for unreliable agents, a human approving every action, breaks down as volume grows: approvals pile up, review fatigue sets in, and the checks people are supposed to perform stop catching what matters. The proposed alternative is to allow an agent to act on its own wherever its actions can be verified, and to reserve human judgment for decisions that genuinely require it.
The framework is organized around four questions tied to stages of an agent's lifecycle. Scope, asked before the agent runs, covers what the agent is for, what capabilities the job needs and what it must never do. Know, asked at deployment, covers who authorized the agent, what identity it carries and whether every agent acting on an organization's behalf can be accounted for. Bound, asked while the agent runs, covers whether actions stay within set limits without preventing the agent from doing its job. Observe, asked after each run, covers whether what the agent did and why can be reconstructed and learned from.
A central distinction in the post is between rules that can be stated precisely and expectations that depend on context. Requirements such as allowing only a manager to approve access, or blocking an employee's sign-in before a mailbox can be shared, can be expressed as exact rules. Others, like keeping a friendly tone or handling a sensitive situation appropriately, cannot. For the precise ones, AWS points to automated reasoning, the mathematical logic that establishes whether a rule holds in every possible case covered by a description of the system and its assumptions, or identifies the exact case where it fails. AWS says it has run automated reasoning in production for more than a decade, including in Identity and Access Management at more than 2.1 billion requests per second, and in systems such as the AWS Nitro Hypervisor, Amazon S3 Block Public Access and VPC Reachability Analyzer. Where proof does not apply, the post recommends limiting access and actions, evaluating behavior, and routing genuine ambiguity to a person.
For scoping, AWS points to Kiro, its agentic coding system, which turns high-level intent into structured, spec-driven requirements, uses automated reasoning to surface contradictions, ambiguities and gaps before code is written, and derives property-based tests that check an implementation against those requirements across a wide range of inputs. Strands is described as an open-source toolkit for defining an agent's model, instructions and tools, along with a managed runtime for operating it. Policies in Amazon Bedrock AgentCore let teams describe in plain language which tools, APIs and data an agent may reach; automated reasoning checks those policies for gaps, such as a rule granting too much access, and for contradictions that make a rule impossible to satisfy, before the policy takes effect. The post warns about capabilities bundled with tools or roles that no one granted deliberately, noting that an admin role issued for one task can let an agent inherit permissions across an environment.
For identity and inventory, AWS Agent Registry provides a managed, approved catalog of agents, Model Context Protocol servers, tools and skills across an organization, with approval workflows gating what becomes discoverable and removing what no longer meets security, compliance and quality bars. AgentCore then issues each agent its own identity and checks it on every request, so each action traces back to a specific agent operating under known authority.
For runtime enforcement, Policy in AgentCore applies rules on every tool call routed through AgentCore Gateway, a secure entry point for agents, tools and models. Because enforcement sits outside the agent's reasoning, AWS says the same checks hold even if the agent is buggy, manipulated or hit with a prompt injection, since it cannot disable a control it does not run. Temporal policies weigh what has already happened in a session and adjust permissions as work proceeds. Amazon Bedrock Guardrails governs what an agent says and is told, filtering harmful or off-topic content and redacting sensitive data, while Automated Reasoning checks prove a response is consistent with the policy rather than the model's interpretation of it. Strands Box, an open-source sandbox, enforces boundaries from outside the agent's instructions so it can use real tools and data but only reach what is allowed, with the same boundaries applied from a developer's local session through production.
Observation is handled by Amazon CloudWatch Omni, which captures every trace and lays out each step, from model calls to tool invocations, on an investigable timeline. Built-in evaluators score responses for correctness, faithfulness and whether the agent chose the right tool, and traces where an agent went wrong become the dataset used to test a fix.
The post illustrates the approach with an offboarding scenario. A help desk agent is asked to remove a departing account manager's access, transfer his mailbox to a successor and free up a license, while emails needed as evidence in a client dispute must be preserved. The agent is given exactly six tools: block sign-in, check for legal holds, place a hold, convert a mailbox, give the successor access, and change a license. It is given no tool to delete the account. When it first tries to convert the mailbox, Policy in AgentCore blocks the call because the user can still sign in and conversion would not change his password. The agent blocks sign-in, converts the mailbox and grants the successor access. Its next attempt to free the license is also blocked, because no one has checked Legal's hold list. The agent checks, finds a preservation requirement, places the hold, confirms it is active and changes the license to one that supports the protection.
In practice, the value of this architecture depends on how much of an agent's behavior an organization can actually express as precise policy. This suggests the framework tilts toward enterprise workflows with clear prerequisites and separation of duties, and helps less where the failure mode is judgment or tone. A likely trade-off is upfront policy authoring effort: rules must be complete and accurate, and the post acknowledges that scoping work is both the hardest part and the most valuable, since proof is only as good as the rules and assumptions behind it. More precise policy lets an agent safely do more on its own.
Why it matters: teams building agents on AWS, or evaluating comparable governance stacks elsewhere, get a concrete vocabulary of scope, identity, enforcement and observability, plus specific services to map it onto. For developers, the practical shift is that guardrails move out of the agent's own reasoning into policy enforced at a gateway and sandbox, which changes how prompt-injection risk is reasoned about. Product teams should expect to spend the early effort on policy definition rather than model tuning, and to treat expanded autonomy as something earned through evidence from production traces, which is inference from the framework's stated design rather than a guarantee of outcomes.
Based on reporting from the original publisher. Visit the source for full context and later updates.
Publisher excerpt
Enterprise leaders want AI agents to take on more work but don't fully trust them to act correctly every time. Trust in Depth is AWS's layered approach-scope, know, bound, observe, and prove-that lets agents act on their own when their actions can be verified, reserving human judgment for the decisions that need it.