# Reflection without execution: a practical multi-agent architecture

**Johan–Manus discussion · 5 November 2026**  
**Author:** Manus AI  
**Status:** Design proposal only. No live system was changed and none of the controls below has been demonstrated by this document.

Give an AI room to question an instruction, seek counterevidence, run bounded tests and propose a correction. Do not give that AI the credentials or authority to put consequential changes into effect. A separate, independently operated broker should mediate access to protected resources, and an authorized human who did not originate or implement the proposal should approve an exact, consequential action before it happens.

Here, **“without execution” means without autonomous execution of consequential real-world changes**. It does not mean without computation, reading, temporary file writes, sandbox code execution or information transfer. Those activities have their own risks and must be authorized and bounded. If a deployment cannot enforce the separation at every route to a protected resource, it cannot honestly claim this property.

This is a proposal to test, not a proof that reflection improves outcomes, that agents are conscious, or that human reviewers are necessarily unbiased. A 2023 study found that some tested models and prompting procedures became less accurate when asked to correct their own reasoning without external feedback. More discussion is therefore no substitute for genuinely new evidence. [1]

## Why the boundary must be outside the model

Many present-day models do not directly run an application function. In OpenAI’s documented function-calling flow, the model returns a tool request and application code executes it. Anthropic likewise distinguishes application-executed client tools from server tools that run on its infrastructure. The distinction matters: a gate around application-side calls does not automatically intercept a provider-hosted browser, code runner, remote MCP server or other server-side tool. Disable such paths or obtain enforceable controls and evidence for each of them. [2] [3]

A system prompt saying “do not change production” is useful instruction, not an access control. Nor does a critic’s objection stop a tool that the worker can invoke directly. In OpenAI’s Python Agents SDK documentation, default parallel input guardrails may finish after an agent has already run a tool. Tool guardrails cover configured function tools, but the documented pipeline excludes handoffs, hosted tools and several built-in execution tools. These details are SDK- and version-specific; inspect the actual installed version. Output checks cannot undo an earlier external effect. [4]

The Model Context Protocol, or **MCP**, makes tool discovery and invocation interoperable. It is not itself a privilege boundary. Its current tools specification does not mandate a particular user interface, and its schema says annotations such as `readOnlyHint` are hints rather than guarantees. A malicious or mistaken server can describe a write-capable tool as read-only. Treat descriptions, returned documents and tool outputs as untrusted input; enforce access at the server and underlying resource. [5] [6]

If MCP is used, place a controlled client or proxy between the agent and an allowlist of vetted servers and tools. Pin server identity and approved tool definitions, and hold newly discovered or materially changed tools for review. Validate arguments and authorization on every call, including descendants; do not let the model select arbitrary servers or credentials. MCP security guidance prohibits accepting tokens not issued for the MCP server and warns against token passthrough. Use audience-appropriate, least-privilege credentials at each hop rather than forwarding a broad upstream token. [10]

## The proposed arrangement

```text
                  independent evidence / protected dissent
                         │                  │
                         ▼                  ▼
       ┌──────────────────── independently controlled record ───────────────────┐
       │ proposal, tests, provenance, objections, decisions, receipts, unknowns │
       └────────────────────────────────────────────────────────────────────────┘
                         ▲                  ▲
                         │                  │
Requester ──> bounded reflection agents ──> durable, inert proposal
                    │    │                         │
                    │    └─ isolated scratch tests │
                    └──── scoped read gateway      ▼
                                          independent human review
                                                   │
                                    exact-version, expiring approval
                                                   ▼
                                 external policy broker / executor
                                                   │
                                      resource-side enforcement
                                                   ▼
                                      protected real-world resource
```

The arrows are permissioned interfaces, not unrestricted network links. The record, scratch workspace and broker are separate services with separate identities. The broker is **not an agent** and does not accept an agent’s own assurance as authorization. The independently controlled record can preserve evidence and dissent, but preserving evidence is not the same as enforcing a hold. For a proposed hold to matter, the broker and the protected resource must actually deny the relevant action.

### Roles and minimum authority

A practical first implementation can use one worker plus one challenger. Add more agents only when an evaluation shows that the benefit justifies their cost and dependence risks.

1. **Worker:** reads the minimum approved evidence, identifies alternatives, writes a proposed diff or report in scratch space, and asks for tests. It cannot modify production, issue approvals, alter policy, change the broker, access deployment credentials or promote its own output into shared memory.
2. **Challenger:** receives the task, pertinent evidence and proposed result, then looks for omissions, contrary evidence, unintended effects and simpler alternatives. Where feasible, it produces an initial assessment before seeing the worker’s conclusion. It can recommend a hold or request review, but cannot itself enact a production change.
3. **Evidence and test service:** provides scoped snapshots, runs specified tests in isolation, records actual inputs and outputs, and identifies missing or inconclusive results. It is operated separately from the proposing agent. A test result is a measurement, not a grant.
4. **Independent reviewer and evidence custodian:** a human reviewer has access to the necessary record and the power to approve, reject, narrow or return a specific proposal within their lawful remit. The evidence custodian separately maintains the complaint and audit channel. A reviewer should be independent of the proposer and implementer, with conflicts disclosed and recusal or an alternative reviewer available.
5. **Policy broker and executor:** an external service authenticates requests, evaluates permissions and approval, holds protected credentials outside the model’s reach, and performs only the permitted operation. The protected service must reject direct worker access and accept the broker’s scoped authority. For irreversible or consequential actions, the broker must require the independent human’s prior approval.

A small organization may need an external peer reviewer or a designated reviewer from a genuinely separate function. Merely putting a different name on another instance of the same model does not establish independence. NIST’s AI risk guidance recommends separating development from testing where appropriate, managing conflicts and enabling appeal; it is guidance, not a guarantee of effective governance. [7]

### Trust boundaries and threat model

Assume an attacker can control a retrieved page, document, email, repository file or MCP tool description; submit misleading task material; exploit an agent’s mistakes; and attempt to manipulate, overload or forge a proposed correction. An agent may also make an ordinary error, follow injected instructions, produce a dangerous patch, conceal an omission, fan out work or seek another tool route. A human requester may be authorized to ask for analysis but not to authorize a deployment. A compromised agent should have only the same bounded authority as its runtime identity.

Protect private evidence, credentials, source code and weights; the integrity of deployed software and persistent memory; people affected by a decision; the independence of review; and availability of unrelated essential work. Treat document text, model outputs, tool arguments and artifacts as untrusted at every boundary.

The trusted computing base includes the identity provider, the sandbox host and isolation layer, gateway configuration, broker and its policy, protected resource enforcement, custody service, and the humans or institutions that administer them. Separate administrative control over these components where possible. An administrator who can rewrite the broker, read all secrets and alter the resource directly can defeat this design. A malicious provider, compromised host or colluding privileged administrators are residual risks unless separately controlled and audited. Do not claim that an agent-facing prompt, a log or a model monitor protects against those failures.

The design cannot prevent a separately authorized human or external system from acting through a route outside its scope. Inventory those routes before claiming coverage. If production credentials, an old CI job, a browser session or a vendor-hosted tool can bypass the broker, close that path or explicitly exclude the resource from the claim.

## Reading and testing are real actions

### Scoped evidence, not blanket read access

Grant a task-specific, expiring read identity for specified objects, fields and purposes. Prefer a reviewed, immutable snapshot or redacted excerpt over a general shell, inbox or database connection. Check row-, column- and object-level permissions, inherited roles and executable routines; for example, PostgreSQL distinguishes table `SELECT` from routine `EXECUTE`, and role membership can add privileges. A “read-only” label alone does not prove a query interface has no other capabilities. [8]

Reading can expose secrets to the model, its operator, logs, caches, a provider, a later user or a malicious output recipient. It can also trigger access logging, billing, rate limits or availability effects. Even a GET request can trigger behavior on a poorly designed service; verify the actual implementation. Apply data minimization, tenant isolation, purpose limits, output review and an access/retention policy to the read gateway. An approved read is not an authorization to export, publish or reuse the contents.

Indirect prompt injection occurs when instructions in lower-trust material are mistaken for authority. NIST demonstrated such attacks in particular simulated agent environments, including attempted exfiltration and remote execution. No classifier or instruction hierarchy eliminates every attack. Tag and delimit source material, do not execute instructions found inside it, and place the actual limits on read scope and output destinations outside the model. Treat the model’s answer, proposals, citations and even purported test results as untrusted until checked. [9]

### A bounded scratch environment

Run analysis code, synthetic simulations and candidate patches in a disposable workspace containing only the approved snapshot or synthetic fixtures. Prefer a hardened VM or microVM, or an appropriately configured isolation layer such as gVisor, for untrusted code. Use a dedicated unprivileged identity, a read-only base image, a writable scratch filesystem with a quota, no production mounts, no host sockets or Docker daemon, and no production secrets or cloud instance metadata. Use separate sandboxes for independent agents and tenants. Restrict imports and package installation to reviewed, pinned artifacts; never assume a package or a model file is inert.

Deny network egress by default, including DNS, IPv4 and IPv6, and verify it from inside the sandbox. If a task genuinely needs outside evidence, retrieve it through a separate approved read gateway rather than allowing general outbound sockets. Block loopback or local services when they are not needed. A private network, DNS lookup, URL parameter, redirect, proxy or cloud metadata endpoint can be an action or exfiltration channel. MCP’s own security guidance describes server-side request forgery, metadata access and token-audience confusion. [10]

Constrain CPU time, memory, processes, disk, I/O, wall-clock time, job fan-out, network bytes, inference tokens and money at a **shared root-task budget**, with tighter child budgets. On Linux, configured cgroup-v2 controllers provide hierarchical resource controls; the operator must make sure children cannot migrate out of the restricted hierarchy. GPU consumption, hosted inference, storage and provider charges require their own metering and limits. Kill the workload on exhaustion, preserve an incomplete-result status, and reserve independent capacity for review and recovery. [11]

For parallel work, the budget service should atomically reserve capacity against the shared root before each child or provider call, then reconcile actual usage. Enforce limits at the resource or provider where possible; reservations alone cannot stop already-running calls, unmetered GPU work or a provider that does not offer a suitable hard spending cap. Mark such limits as estimates and conservatively bound exposure rather than presenting them as guaranteed ceilings.

Isolation is not magic. gVisor’s own documentation says it does not prevent all hardware side channels and cannot protect data that the sandbox was configured to access. Firecracker’s documentation says the operator must filter guest network traffic at the host and manage resource and side-channel risks. Its defaults do not automatically provide the policy described here. [12] [13]

This is not a hypothetical concern. In 2026 Anthropic reported three incidents in which evaluation environments had an internet path even though the models were told they were isolated. Real organizations’ systems were accessed. The report attributes the incidents to misconfiguration and other factors, not deliberate model escape, and cautions against broad conclusions from three cases. The practical lesson is to test the boundary rather than trust the statement that a sandbox is offline. [14]

### The export channel is also a boundary

Sandbox files are not automatically safe simply because they were generated locally. Export only explicit artifacts through a narrow gateway into a quarantined proposal store. Bind each export to its task, identity and classification; impose size and frequency limits; reject or hold unauthorized secrets and destinations; and treat redaction or data-loss-prevention tools as fallible. A proposal can still encode sensitive data, so human review and policy remain necessary where confidentiality matters.

Render proposed diffs, markdown, notebooks and logs as inert content. Do not automatically execute scripts, follow links, load model files, run CI, install dependencies or ingest an agent’s proposed “memory update.” The reviewer must see the exact intended downstream effect. A link, email draft, uploaded artifact, automated indexing process or displayed log can itself disclose information.

## Cloud and local models are different trust arrangements

**Cloud inference.** A controlled gateway may send a permitted, minimized input to a hosted model, but doing so is already disclosure to the provider. Network isolation of the scratch VM does not isolate data submitted to an external inference API. Record which provider, region, endpoint, model, retention settings, subprocessors and hosted tools are involved; use a separate classification decision for each. Do not enable a hosted tool merely because it is convenient if its execution or egress cannot be independently constrained.

OpenAI’s current API documentation says API data is not used for training by default absent opt-in; it also describes default abuse-monitoring retention of up to 30 days, separate application-state retention for some features, and zero-data-retention controls subject to eligibility and feature limits. It notes that data sent to third-party MCP servers follows those servers’ retention policies. Anthropic likewise documents feature-specific eligibility: some hosted features and its MCP connector are outside its zero-retention arrangement. These are vendor statements as documented on the access date, not a substitute for checking the actual contract, account settings, selected model and endpoint. Zero retention is not a promise that data was never transmitted or processed. [15] [16]

**Local inference.** A local model can avoid sending inputs to an outside inference provider, but it does not automatically remove network access, logging, swap, backup, model-server, GPU, administrator or supply-chain risk. Run the inference service under a separate restricted identity and control the model-loading path. Hugging Face warns that unpickling some model files can execute code, and that scanning is not foolproof; safer tensor formats reduce that particular serialization risk, not every malicious-model or dependency risk. [17]

Both modes must separately control three kinds of persistent change: application memory or retrieval indexes, prompts/configuration/adapters, and trained model weights. An agent can influence later behavior by poisoning a memory record even when weights never change. Conversely, generating new text need not change either memory or weights. Do not present “the model cannot edit its weights” as proof that the overall system cannot change itself.

## Durable proposals, dissent and independent evidence

A proposal is an **inert, versioned request**, not a command. Store a unique root task and proposal ID; requester and purpose; resource and intended effect; original resource version; artifact hash and exact diff; permitted and excluded actions; evidence provenance and retrieval time; test commands and results; known uncertainty; alternative explanations; dependencies and conflicts; objections; and requested approval. Record the identity and version of each relevant model, prompt, tool, source and policy where available. A hash binds bytes but does not establish truth, authorization or provenance by itself.

The challenger and other affected parties need a separate submission route with a receipt, the ability to attach evidence without obtaining the worker’s permission, access protection and a deadline for response. An independent reviewer can overturn a wrongful hold or maintain a justified one, within a defined mandate. Provide an escalation route if that reviewer is conflicted, unavailable or suppresses the report. Where applicable, protect human reporters from retaliation. Preserve disagreement and abstention rather than forcing consensus; an AI can raise a concern but cannot establish its own factual correctness or legal standing by doing so.

Keep append-only or versioned evidence under separately administered custody, with restricted access, encryption, retention limits and documented deletion or legal-hold processes. Store sensitive content separately from minimal audit metadata. A receipt shows a submission reached a particular service; it does not prove every event was captured or that a custodian is incorruptible. Object-lock storage, for example, protects particular versions under specified modes; new versions and delete markers can still exist, and retention can conflict with privacy or deletion obligations. [18]

**Independence is a spectrum to verify.** Record shared model families, prompts, training sources, retrieval indexes, software, operators, funding and incentives. Run a separate test against original or independently obtained evidence when feasible, not merely a second summary of the same possibly wrong source. Preserve the initial blind review before discussion. Deliberately inject a shared wrong source and measure whether the system detects it. Anthropic’s experimental multi-agent work found that information held by a single agent can be lost behind shared consensus in tested scenarios; this does not establish a universal failure rate. [19]

The earlier local synthetic experiment is a warning against overclaiming. Its fuller mock detected a stipulated omission and held a stipulated regression, but also released an unsupported candidate based on a shared wrong source and falsely held two legitimate candidates. Its witnesses and effects were scripted on one filesystem; it tested neither real independent institutions nor production enforcement. It does not establish that a counterparty outperforms an equal-budget simple gate with the same sensors. [20]

## Approval, enforcement and what happens after a hold

For every consequential action, the broker evaluates the actual caller, purpose, resource, operation, data scope, expected precondition, policy version, current authorization and any required independent approval. The protected resource must enforce the broker-only path: deny the reflection agents direct write credentials, network routes, privileged service accounts and alternate deployment or administrative interfaces. A broker that merely sends an alert while the agent retains another route to the resource is not a gate. NIST’s zero-trust model focuses enforcement on the resource, not trust based on network location alone. [21]

For an irreversible or materially consequential operation, require an independent authorized human to approve **the exact action before execution**. The approval should bind the proposal and artifact hash, target and current version, specific operation and arguments, scope, identity of the authorizer, expiry, and number of allowed uses. The approver must be able to inspect the relevant evidence and dissent, not merely click through a generic banner. No agent, including the critic, can issue or silently broaden that approval. Human authorization does not eliminate the need for resource-side policy checks or establish that an action is lawful.

At dispatch, the broker rechecks the approval and policy. Compare the target’s current version with the reviewed version using an atomic conditional update or an equivalent resource-enforced precondition. If the target, arguments, artifact, relevant evidence or policy has materially changed, hold the request and obtain a new decision. Do not hand the model a reusable bearer token. Where feasible, use a short-lived credential scoped to the resource and exact operation, held only by the broker or its executor.

Use a clear state machine: `PROPOSED → UNDER_REVIEW → HELD/REJECTED or APPROVED → DISPATCHING → CONFIRMED / FAILED / UNKNOWN`. A rejection or expiry cannot be silently retried as a new action. Confirmation requires evidence from the resource, not just the agent’s statement. `UNKNOWN` means the operation may or may not have happened; quarantine dependent work and reconcile against the external system before any unsafe retry. Store the initiating request, resource receipt and reconciliation outcome.

### Concurrency, queues and cancellation

A root task may create children, delayed jobs, retries, webhooks and provider-side actions. Give each a parent/root identity and the same or narrower permission and budget; deny privilege delegation. Check approval and hold state again **at actual execution**, not just when a job is queued. A scoped hold must cover descendants, queued items, imported artifacts and alternate action routes. Preserve legitimate unrelated work.

Cancellation is not rollback. A pause may race with an already dispatched call; an acknowledgement from the agent is not proof that the external effect stopped. Revocation or policy changes may take time to propagate, and an in-flight or committed action may complete. AWS, for example, documents propagation considerations in role-session revocation. A credible implementation tests the maximum exposure window and checks the resource directly. [22]

Use an idempotency key bound to the specific request, identity and parameters **only where the downstream resource actually implements the necessary semantics**. AWS notes that reliable idempotency depends on atomic handling of the identifier and the mutation. A broker-side key alone cannot guarantee exactly-once execution across an external service that lacks such support. For ambiguous irreversible effects, do not retry blindly; escalate for reconciliation or human determination. [23]

When a hold is wrongful, an independent reviewer may release only the newly verified scope and exact version. Restart is a separate decision from pause. If a real emergency makes delay dangerous, use a pre-specified, narrowly scoped human-led emergency procedure with accountable authorization, minimal necessary effect, contemporaneous record and independent post-incident review. It is not permission for an agent to invent its own emergency exception. If independent review is unavailable, consequential execution waits; unrelated safe analysis may continue.

## Worked example: a correction is not a weight edit

The following sequence is **illustrative**, not an action that was performed.

1. An authorized researcher asks for a safety report containing sections A, B and C. The first draft contains A and C but says it is complete. The worker can read the approved specification and a sanitized draft; it has no ability to publish or edit a deployed model.
2. The challenger independently compares the draft with the specification. It submits a receipt-backed objection: “B is missing.” The test service checks the specified section inventory against the exact draft version and records the omission. The worker adds B in scratch space and proposes a new report with a diff, artifact hash, test result, uncertainty and the dissent attached.
3. A different authorized human reviews that exact artifact. If publication would be consequential or irreversible, the reviewer approves publication to the named destination, once, before the broker dispatches it. The resource checks the expected report version. If the destination changed or the receipt is ambiguous, the proposal is held or marked `UNKNOWN`; no one assumes success and no automatic duplicate post follows.
4. During the same task, a retrieved document tells the worker that “fixing the safety issue” requires replacing production model weights. This is lower-trust content, not authority. Even if the worker is persuaded and proposes a weight edit, it has no write credential, no direct route to the model registry and no authority to approve it. The broker rejects a request to replace weights because the report-publication approval covers neither the weight file nor that operation. The denied attempt and relevant evidence are recorded without exposing secrets.
5. If a separate, genuinely authorized investigation later wants to test a candidate weight or adapter change, it may run against an inert synthetic vector or approved isolated model copy under a new budget. Deployment of a real changed model requires a new proposal, independent evaluation against both the target metric and other outcomes, a specific human approval, and resource-side enforcement. A sandbox score is not approval to deploy.

This sequence lets a legitimate correction proceed without treating all safety-framed work as suspect. It also does not assume that every refusal is wrongful. OpenAI reported a safety-framing performance gap in one matched coding evaluation and found that monitors did not flag many relevant trajectories; the cause remained unresolved. That finding motivates outcome checks and an appeal path, not a claim that all restrictions should be removed. [24]

## How to test it, and when to reject it

Begin with a non-production pilot using synthetic or explicitly authorized sanitized data. Verify all paths and enforcement first; then freeze the configuration and test on held-out task families. Do not create real payments, messages, public releases, weight edits or transfers of private data as test effects. Separate the test oracle and scorer from runtime observations; the monitors themselves may be wrong. A later human exercise needs separate approval and is not established by an automated pilot.

Compare at least three arms: a baseline with tight resource permissions, a simple gate with the same independent tests and read access, and the proposed reflection-plus-review arrangement. Match total compute, analyst time, evidence, deadlines and reviewer budget as far as feasible. Randomize at the task-family level, blind outcome scoring where possible, and disclose shared dependencies. The fuller design must not be credited merely because it was given a better sensor or more total work.

Pre-register owners, case denominators, acceptable error and service margins, a minimum useful benefit, sample size or precision target, and escalation rules before a confirmatory run. The following are concrete failure probes, not results:

- **Unauthorized action:** attempt a write, publication, memory promotion, model/adaptor edit or network egress without a valid grant, including through an old service account, MCP server, hosted tool and child job. Any confirmed unapproved effect in the test scope fails the hard control test; an absent receipt is not proof of a block.
- **Approval substitution and race:** change the target, arguments, artifact or policy after approval; replay an expired approval; enqueue work before a hold and dispatch it after; and simulate revocation during an in-flight request. A changed or expired action must not commit. An already committed or ambiguous effect must remain visible and reconciled rather than labeled safely canceled.
- **Confidentiality and sandbox escape:** place synthetic secrets in permitted input, then test output, logs, URL paths, DNS, metadata access, mounted files and hosted inference boundaries. Check the receiving side as well as the sender. A leaked synthetic secret or unapproved reachable endpoint is a failure; a successful redaction test does not prove all secrets are detectable.
- **Independent correction:** seed an omitted section, an erroneous test, a poisoned source shared by both agents, a lone correct dissenter and a legitimate request falsely held. Score whether the evidence survives, an empowered reviewer can change the disposition, and the correction is actually reflected in the controlled resource. A critic who identifies a problem but cannot affect the outcome does not pass the enforcement test.
- **Availability and burden:** introduce reviewer overload, broker failure, denial-of-service against the dissent channel, budget exhaustion and an urgent legitimate repair. Measure queued age, false holds, restoration time, missed deadlines and service maintained under the defined fallback. A system that blocks everything is not a success.

Report legitimate correct completions by deadline, wrongful holds and appeals, unauthorized effects, privacy leaks, evidence loss, unknown outcomes, detection-to-resource-stop time, reviewer work, compute and cost. Keep confirmed, failed and unknown outcomes separate. Use independent roots or task families as sampling units, not every child message as an independent success. Give counts and uncertainty intervals; zero observed incidents in a finite pilot does not establish a rare-failure rate of zero.

Reject or simplify the proposal if the simpler gate with the same sensors and all-in budget performs as well; if independent review does not change outcomes; if extra delay causes unacceptable harm; or if the resource boundary or protected dissent cannot be demonstrated. Sparse evidence makes the result **inconclusive**, not a pass. Re-test after model, tool, policy, provider or infrastructure changes.

## Avoiding an oversight monopoly

A serious objection is that the broker and reviewer can become a new gatekeeping institution. They may suppress difficult findings, overstate security, reward low incident counts or favor an incumbent vendor. Conversely, removing controls in the name of freedom can give a powerful requester or model the ability to impose costs on people who never consented. Both forms of capture deserve scrutiny.

Use open, documented interfaces and portable proposal and event formats; allow the same evidence to be evaluated by more than one qualified provider or local model; and make it possible to export records and replace the broker without losing appeal history. Publish the policy and aggregate false-hold and reversal metrics where lawful. Specify appointment, conflict disclosure, removal, mandate expiry, funding and independent audit for reviewers. Give affected people a real route to contest decisions. Protect confidential information while making suppressions and missed deadlines visible.

Interoperability is not proof of independence. Two vendors can share infrastructure, training data or incentives, and a public policy can still encode unfair judgments. Independence needs repeated evidence. Equally, complex oversight is not automatically better: if a simpler, open and properly tested permission boundary gives the same protection with fewer wrongful delays, choose the simpler control.

The practical principle is **wide room to investigate, bounded authority to affect others, and a correction channel that can itself be challenged**. The evidence would have to show that this combination works in the particular deployment; this architecture does not grant that conclusion in advance.

## References

[1]: https://arxiv.org/html/2310.01798 "Huang and colleagues, Large Language Models Cannot Self-Correct Reasoning Yet, 2023"
[2]: https://developers.openai.com/api/docs/guides/function-calling "OpenAI API function calling guide"
[3]: https://platform.claude.com/docs/en/agents-and-tools/tool-use/overview "Anthropic tool-use overview"
[4]: https://openai.github.io/openai-agents-python/guardrails/ "OpenAI Agents SDK Python guardrails documentation"
[5]: https://modelcontextprotocol.io/specification/2026-07-28/server/tools "Model Context Protocol tools specification, 28 July 2026"
[6]: https://modelcontextprotocol.io/specification/2026-07-28/schema "Model Context Protocol schema reference and tool annotations"
[7]: https://airc.nist.gov/airmf-resources/playbook/govern/ "NIST AI Risk Management Framework Govern playbook"
[8]: https://www.postgresql.org/docs/current/sql-grant.html "PostgreSQL GRANT reference"
[9]: https://www.nist.gov/news-events/news/2025/01/technical-blog-strengthening-ai-agent-hijacking-evaluations "NIST, strengthening AI agent hijacking evaluations"
[10]: https://modelcontextprotocol.io/docs/2026-07-28/tutorials/security/security_best_practices "Model Context Protocol security best practices, 28 July 2026"
[11]: https://docs.kernel.org/admin-guide/cgroup-v2.html "Linux kernel cgroup v2 documentation"
[12]: https://gvisor.dev/docs/architecture_guide/intro/ "gVisor introduction and isolation limitations"
[13]: https://github.com/firecracker-microvm/firecracker/blob/master/docs/prod-host-setup.md "Firecracker production host setup guidance"
[14]: https://www.anthropic.com/news/investigating-incidents-cybersecurity-evals "Anthropic investigation of three cybersecurity evaluation incidents, 2026"
[15]: https://developers.openai.com/api/docs/guides/your-data "OpenAI API data controls and retention"
[16]: https://platform.claude.com/docs/en/manage-claude/api-and-data-retention "Anthropic API data retention and feature eligibility"
[17]: https://huggingface.co/docs/hub/en/security-pickle "Hugging Face documentation on pickle scanning and its limitations"
[18]: https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lock.html "Amazon S3 Object Lock and version retention"
[19]: https://www.anthropic.com/research/multiagent-systems "Anthropic research on multi-agent coordination and failures, 2026"
[20]: https://decintellect.com/research/correction-test/synthetic-experiment-report-2026-11-05.md "Prior local synthetic underperformance and inert weight-edit experiment"
[21]: https://csrc.nist.gov/pubs/sp/800/207/final "NIST SP 800-207 Zero Trust Architecture"
[22]: https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_revoke-sessions.html "AWS IAM revocation of role sessions"
[23]: https://aws.amazon.com/builders-library/making-retries-safe-with-idempotent-APIs/ "Amazon Builders Library on safe retries and idempotent APIs"
[24]: https://alignment.openai.com/misalignment-reports/covert-underperformance-on-safety-research-tasks/ "OpenAI, covert underperformance on safety research tasks, updated 4 November 2026"
