MCP policy enforcement is not established by a policy file. A configured policy shows that someone wrote the rules; it does not show that the server enforces the outcomes those rules specify. AWS has published two bulletins in 2026 for the AWS API MCP Server in which a configured policy could stop enforcing what its operator wrote it to enforce, by two different routes. An operator has to verify that the enforcement layer rejects the operations the policy intends to deny and applies the elicitation it intends to require, and this Field Note is built around the test that does it.
What the Two AWS Bulletins State
Both bulletins concern awslabs.aws-api-mcp-server, the open-source server that lets an AI assistant run AWS operations in a customer's account, and its optional operator-written security policy. Everything in the table is AWS's own bulletin text, read on the bulletin pages on November 21. NOT STATED marks something the bulletin does not say; it is not a finding that the answer is no.
| July: 2026-063-AWS | November: 2026-176-AWS | |
|---|---|---|
| Published | 7/23/2026 | 11/10/2026 |
| Impacted versions | >= 0.2.13 and < 1.3.47 | >= 0.2.13 and < 1.5.1 |
| Fixed in | 1.3.47 | 1.5.1 |
| Mechanism | If initialization of the policy enforcement data fails, the server keeps running with the per-request policy check skipped for the lifetime of the process | Operation names were normalized incorrectly before comparison, so names with consecutive capital letters never matched a correctly written entry |
| Precondition stated | A policy configured without the fail-closed modes enabled; the bulletin does not describe those modes | A custom security policy |
| Lists affected | Operations the policy was configured to deny or gate | denyList and elicitList |
| IAM statement | IAM permissions on the configured credentials remain in effect and are unaffected | NOT STATED |
| Workaround | Either of two: least-privilege IAM credentials, or restart after connectivity is restored | None other than upgrading |
| Deployment scope | NOT STATED | NOT STATED |
| Exploitation | NOT STATED | NOT STATED |
Two details matter for what follows. The IAM sentence appears in July and not in November, so nothing here assumes it for November. And neither bulletin says whether the server logged a warning or raised an alert when enforcement was absent or ineffective, so this post makes no claim about visibility.
MCP Policy Enforcement Can Fail in Two Different Ways
July is the first route. The data the policy needs fails to load at startup, the server continues, and the per-request check is skipped for as long as the process lives. Enforcement is absent. What a rule should do when its input cannot be evaluated is the subject of Rack2Cloud's Policy Fail Mode post: deny, fall through or allow is a decision someone has to make per rule. July is an instance of that failure, and this post adds nothing to the design argument. It adds the question that comes after the decision: can you show that the behavior you chose is the one running?
November is the second route, and a different class. The policy data is present and the check runs. The comparison fails: the operation name is normalized incorrectly first, so a correctly written entry never matches an operation whose name contains consecutive capital letters. That applies to deny entries and to entries that require elicitation. The control is running, but for this defined class of names the intended policy outcome is not enforced.
| July | November | |
|---|---|---|
| Policy data | Fails to load | Present |
| Enforcement check | Skipped | Runs |
| Result for affected operations | Enforcement absent | Enforcement ineffective for affected names |
The shared concern is the inference operators make. A configuration file, a running server and an absence of visible errors are all consistent with enforcement, and none of them shows it.
Where the Hard Deny Lives
The MCP policy enforcement layer is one control. The IAM permissions on the credentials the server uses are another, and they do not depend on the server's own code. The July bulletin says IAM permissions remained in effect, calls IAM the primary access control, and lists least-privilege credentials as a workaround. The November bulletin says none of that. This post does not claim that IAM would have stopped any operation in November, because that depends on the permissions on the credentials in use.
The design decision is which control you rely on to hold an operation that must never run. This is analysis, not AWS guidance: put those operations out of the credentials' IAM permissions, and treat the MCP policy as a second control for operation gating and elicitation requirements that needs its own verification. That is an architectural recommendation, not an AWS configuration requirement. How authority moves through the tool layer is covered in Rack2Cloud's MCP security architecture post and, at the gateway, in its Nutanix MCP gateway post. The question here sits below both: whether the policy rules inside the tool server are enforced.
How to Test MCP Policy Enforcement
Testing whether policy outcomes are enforced is runtime control work. The matrix below is a proposed method, not vendor guidance. It separates four checks: version and source-code remediation, initialization failure behavior, operation-name matching and elicitation behavior, and independent IAM authorization. Run it in a controlled environment with disposable credentials. Do not break policy initialization in production to see what happens. Asking each policy layer how it behaves when its data or engine fails is a standing question, and the evidence table in Rack2Cloud's Temporal Guardrails post marks that row as not stated for the engine it examines.
AWS recommends upgrading and ensuring that any forked or derivative code incorporates the fixes; both bulletins say so. Verify the code actually deployed rather than relying solely on its reported upstream version (check 1b).
| Check | July failure | November failure | Passing evidence |
|---|---|---|---|
| 1a. Version | Running version is below 1.3.47 | Running version is below 1.5.1 | Running version is 1.5.1 or later, outside both ranges |
| 1b. Fork and derivative code | Locally maintained code may lack the July fix | Locally maintained code may lack the November fix | Both fixes are confirmed in the code you run, not assumed from the upstream version number |
| 2. Initialization failure behavior | In a controlled environment, exercise the initialization failure boundary using the implementation's identified dependency or a suitable fault-injection method (the bulletin does not identify the dependency; the only related condition it mentions is a server that started while connectivity was degraded) | Not applicable | The failure behavior is explicit and documented: the server refuses to start or refuses requests, and you can point to where that is written |
| 3a. Operation-name matching and elicitation | Test an ordinary operation your policy denies and an ordinary operation it gates by elicitation | Test a denyList operation whose name contains consecutive capital letters, and an elicitList operation with such a name | The denyList operation is rejected; the elicitList operation enters the required elicitation flow and cannot proceed without satisfying it |
| 3b. Re-test after restart | After connectivity is restored, restart and repeat the July tests | After upgrading to a fixed version, repeat the matching tests following restart (a restart is not a remediation for November) | Enforcement remains effective after the restart |
| 4. Independent IAM authorization | Check the credentials' permissions independently of the server | Check the credentials' permissions independently of the server | Unauthorized API actions remain denied when called outside the server |
A passing test is evidence, not proof. One rejected operation shows that one name was rejected. November's boundary is a class of names, so test the members of that class that your policy lists; a pass shows those entries matched, not that every possible name would. A pass on 1.5.1 shows that the two defects AWS described are not the cause of a failure. It does not show the policy layer has no other defect, and for a fork it shows nothing until check 1b is done. Keep the test in the deployment path and re-run it on each upgrade, so it works as a regression check and not a one-time audit.
What This Post Does Not Establish
No claim that either defect was exploited: neither bulletin states exploitation status. No claim about how many deployments are affected. No claim that IAM would or would not have blocked any operation in November. No claim about local versus hosted deployment: neither bulletin states scope. The fail-closed modes named in July are not described in the bulletin and are not covered here, and neither bulletin says what the fixed versions do when initialization fails. Other advisories for this server and for AWS's other MCP servers are separate issues and are outside this post.
Architect's Verdict
MCP policy enforcement has to be demonstrated, not assumed. Two AWS bulletins in 2026 describe two ways a configured policy can fail to enforce its intended outcome: once because enforcement data did not load, once because correctly written operation names did not match.
The real problem is the inference. A policy file, a running process and no visible error all look like a working control, and none of them shows an enforced outcome. The only thing that does is asking the server to do what the policy forbids or gates, in a place where that is safe, and watching it refuse or require elicitation.
Keep the operations that must never run where they do not depend on the tool server's own policy layer, and test the policy layer for the rest. Re-run the MCP policy enforcement test when the version changes, because the version is exactly what changed in both bulletins.
A deny list you have not tried to get past is a configuration, not a control.
Originally published at rack2cloud.com




Top comments (0)