Book a demo
Topics · GOVERNANCE-AGENTS

Payments Sandboxing How It Works | Moring

Sandboxing works by splitting the agent harness control plane from the sandbox execution plane, building the runtime from kernel-enforced primitives with proxy-mediated egress and injected credentials, and deciding every call against signed policy. In payments, the pattern enforces maker/checker boundaries so an agent can prepare work but cannot reach the payment rail.

On this page
  1. Short answer
  2. How it works
  3. FAQs
  4. Related reading
  5. Sources

Short answer

Sandboxing works by splitting the agent harness control plane from the sandbox execution plane, building the runtime from kernel-enforced primitives with proxy-mediated egress and injected credentials, and deciding every call against signed policy. In payments, the pattern enforces maker/checker boundaries so an agent can prepare work but cannot reach the payment rail.

How it works

The mechanism behind sandboxing payment agents starts with a boundary split. In current agent architectures the harness is the control plane around the model: it owns the agent loop, model calls, tool routing, handoffs, approvals, tracing, recovery, and run state, while the sandbox is the execution plane where model-directed work reads and writes files, runs commands, installs dependencies, exposes ports, and snapshots state. Keeping those planes separate lets a payments application keep authentication, billing, audit logs, human review, and recovery state in trusted infrastructure while the sandbox handles stateful execution with narrow credentials and mounts.

Sources: https://developers.openai.com/api/docs/guides/agents/sandboxes

At runtime, the sandbox is built from Linux kernel primitives rather than agent cooperation, which is the property that matters for payments: an agent cannot opt out of it, misconfigure its way past it, or be talked out of it by a prompt. The agent process runs as an unprivileged user with all supplemental groups dropped and no path back to root, while the supervisor and egress proxy run privileged because they enforce the boundary. Per-sandbox firewall rules capture every network call: TCP is redirected to a local proxy that classifies and polices each connection, DNS goes through a stub resolver applying the same domain policy, unknown protocols are dropped with a deny event, and everything else is rejected in the kernel.

Sources: https://docs.lenshq.io/lens-agents/concepts/sandbox/

Egress is proxy-mediated rather than merely filtered. Every outbound connection terminates at the sandbox's own proxy, which enforces domain matching with a default-deny verdict, HTTP-level rules that match method and URL path so read-only access to a payment API is expressible, and TLS interception on governed domains through an ephemeral per-sandbox certificate authority. Credentials never exist inside the sandbox: the agent's environment holds a placeholder, and the proxy substitutes the real value into the request as it leaves, recording the injection. An agent that dumps its own environment, reads its own filesystem, or is tricked into exfiltrating its configuration leaks only placeholders.

Sources: https://docs.lenshq.io/lens-agents/concepts/sandbox/

The policy side of the mechanism is deliberately separated from enforcement. In one published architecture, policy is authored, reviewed, and signed outside the enforcement fabric as a signed bundle; a policy service verifies it and projects it into the runtime's own controls so the sandbox is built from policy the enterprise approved, and a policy gateway decides each governed request the runtime hands it, returning allow or deny with edits. Roles are split across administration point, decision point, information point, and enforcement point so no component can both write policy and enforce it, an evaluation error is a deny, and every component writes audit events joined by a correlation ID and the digest of the bundle that decided.

Sources: https://docs.nvidia.com/agent-policy-fabric/about/architecture

A payments-specific reference example shows the mechanism end to end. An open-source payment-operations assistant for a regulated payments desk screens synthetic outbound payments, explains holds, and prepares cleared items for human review under a platform-enforced maker/checker boundary: the agent can screen, explain, and prepare evidence, but it cannot release or settle a payment because the sandbox policy never grants the payment-rail egress, and a prompt cannot override that network policy. The sandbox may call only its configured inference endpoint and observability service, a separate human checker running outside the sandbox is the only component permitted to call the rail, and the host re-screens each payment before release, with agent evidence and human approval evidence carried as separate, distinctly identified traces.

Sources: https://github.com/NVIDIA/nemoclaw-community/blob/main/examples/payment-ops-hermes/README.md

The mechanism also aligns with how payment system structure is being described at the policy level. An IMF staff note on agentic AI in payments introduces a three-layer conceptual framework separating intent formation and orchestration, authorization and control, and settlement, and highlights risks of authorization traceability, opacity, correlated agent behavior, cybersecurity, and unresolved legal liability, with mitigations including mandate-based authorization, architectural separation of decision making and execution, agent identity frameworks, programmable payment controls, audit trails, and tiered human-in-the-loop models. Sandboxing is the architectural separation of decision and execution made concrete: the agent layer plans, the control layer authorizes, and the settlement layer stays reachable only through governed paths.

Sources: https://www.imf.org/en/-/media/files/publications/imf-notes/2026/english/insea2026004.pdf

That layering answers the governance requirements financial supervisors now attach to agentic systems. A white paper on safeguards for agentic finance at runtime observes that financial institutions are deploying agents that can initiate payments, submit trading orders, approve credit applications, and file regulatory reports, sometimes without human review of each action, and that this shift produces requirements for clearly defined authority, conditions of use, operational limits, accountability, and traceability. A sandboxed runtime with kernel-enforced egress, injected credentials, signed policy, and joined audit events is precisely the runtime shape those requirements describe, which is why sandboxing is becoming the default execution model for payment agents in production.

Frequently asked questions

How does a sandbox isolate a payment agent at the kernel level?

The agent runs as an unprivileged user with supplemental groups dropped and no path back to root, while the privileged supervisor and egress proxy enforce the boundary. Per-sandbox firewall rules redirect every TCP connection to a local proxy and DNS to a policy-applying stub resolver, unknown protocols are dropped with deny events, and everything else is rejected in the kernel. The isolation is built from kernel primitives, so the agent cannot opt out or be persuaded out of it by a prompt.

How are payment credentials handled inside a sandbox?

Credentials never exist inside the sandbox. The agent's environment holds placeholders, and the egress proxy substitutes the real value into the request as it leaves, on the domains the policy names, recording each injection. A payment agent that dumps its environment, reads its filesystem, or is manipulated into exfiltrating its configuration leaks only placeholders, and a proxy credential removed from the sandbox reaches no more than the sandbox policy already allows.

What does policy projection mean in sandboxed payment architectures?

Policy is authored, reviewed, and signed outside the runtime as a signed bundle, then projected into the sandbox's own controls so the sandbox is built from policy the enterprise approved. A policy gateway additionally evaluates each governed request at run time, returning allow or deny with edits, and an evaluation error is treated as a deny. Administration, decision, information, and enforcement roles are held by different components so no component writes and enforces policy at once.

Can a sandboxed agent release a payment in a maker/checker design?

No, and that is the central security property. In a reference payment-operations implementation, the agent screens synthetic outbound payments, explains holds, and prepares release packets, but the sandbox policy omits payment-rail egress entirely, so the agent has neither the route nor the credential to release or settle. Only a named human checker outside the sandbox may call the rail, and the host re-screens each payment before release, keeping agent and human approval evidence separate.

Sources

  1. - federalreserve.gov
  2. - ithandbook.ffiec.gov
  3. - artificialintelligenceact.eu
  4. - eur-lex.europa.eu