AI-agent egress guard

The agent that can't leak.

Your agents read credentials, customer records, and secrets all day — and then send them out again in the next prompt, tool call, or chat message. ShroudCloud puts a guard on that egress path. Real values never reach the model provider or the network.

Live on our own agent stackFail-closed by defaultNothing retained

The leak is egress, not access. A value gets read into an agent's context — a tool result, a log line, a customer email — and then leaves the network in an outbound call. Rotating the secret afterwards is the bill for a boundary that was never guarded.

agent ──▶ tool result ──▶ guard ──▶ engine ──▶ masked text ──▶ model context
                                  │
                                  └── masked values sealed locally (hashes only)

agent ──▶ prompt ──▶ guard :8095 ──▶ /anonymize ──▶ /seal ──▶ model provider
                          └──────── restore locally ◀──────────┘
The guard is the same detection engine that powers ShroudCloud Redact, put in line with the agent instead of a document.

What it does, on each path

Inbound tool results

A hook masks every tool result before it enters model context — shell output, file reads, web pages, APIs. Known secrets are masked exactly; the engine then catches the PII and credentials you could not have listed in advance.

Outbound prompts

An OpenAI-compatible endpoint sits beside the agent. Prompts are masked, the originals are sealed to a vault on your side, and placeholders are restored only in the agent's local context.

Agent replies to chat

A platform-egress filter covers the path the prompt guard cannot see: the message the agent posts to Slack, Teams, or a ticket. Placeholders are never restored here.

Two ways to put it in front of an agent

In the agent — hook

If you control the agent runtime, a hook on the tool-result path masks inbound text. That is the shape running on our own stack today.

Beside the agent — sidecar

If you control the client but not the agent, point its base URL at the guard. One shared instance can serve many agents under bearer auth.

Refuses rather than forwards

Fail-closed is the default: if the engine is unreachable, the guard refuses the request instead of sending unmasked text. Fail-open exists for development, loudly.

GUARD_UPSTREAM=openrouter        # or any OpenAI-compatible provider
GUARD_PROFILE=egress             # secrets + PII, or secrets-only
GUARD_FAIL_MODE=closed           # engine unreachable -> refuse, never forward
GUARD_AUTH_REQUIRED=true         # bearer token on the guard itself

What it catches

Every entity below was live-probed against the engine before it went on this page. No figure on this site is quoted from memory.

EntityExamples
Vendor credentialsAWS access keys, GitHub tokens, OpenRouter / Anthropic / OpenAI keys, HuggingFace tokens, Telegram bot tokens
Identity artifactsJWTs, bearer tokens, OAuth codes, session cookies, private key blocks
PIINames, emails, phone numbers, addresses, dates of birth, US SSNs, credit cards, IP addresses
Unknown secretsHigh-entropy strings in key/value context, PEM bodies, and generic secret shapes with no vendor prefix

Boundaries, stated plainly

A guard you cannot reason about is worse than none. These are the edges of what ships today.

We do not intercept TLS you can't configure.

Transparent interception needs your PKI, your CA trust, and your risk acceptance. It is not shipped, and we say so on the diagram rather than implying it.

Not everything is pattern-detectable.

Vault master passwords, short application passwords, and internal opaque tokens with no vendor prefix cannot be spotted by pattern. Those stay out of agent context at the source.

Whole requests, not streams.

The engine processes complete requests rather than streaming chunks, so streaming responses are on the roadmap, not in the product.

Nothing retained, and how you see it

The engine holds no key and no plaintext.

Masked spans are recorded as hashes. The engine cannot reconstruct what it masked, and it does not store the text it processed.

The reveal key is yours.

Original values are sealed locally against your vault's public key. Restoration happens in the agent's own context, never on a path bound for a third party.

The receipt is a hash, not a copy.

Every guard action lands on a dashboard as a hash and an entity type, so you can prove what was masked without holding what was masked.

FAQ

What breaks in my agent when values are masked?

Placeholders are deterministic, so the same value in always becomes the same placeholder out — the model keeps its context and your workflow keeps working. Restoration happens locally, on the way back.

Does the provider see anything?

The provider sees masked text. The originals are sealed to your vault before the request leaves your network, and the engine never receives them in the clear.

Which profiles are there?

A secrets-only profile for agents that should carry no PII logic at all, the standard egress profile (secrets plus PII), and a strict profile that also masks network identifiers such as IP addresses.

What about pricing?

No pricing announced yet. Early access users set the roadmap and lock in founding terms.

Guard your agents first

Tell us which agents, which models, and what data they touch. We'll tell you which shape of the guard fits — and what it will not cover.

No pricing announced yet. Early access users lock in founding terms.