Security — NornGate | Fail-closed by design

Nothing executes unless every gate says yes.

Most AI platforms are fail-open: the model acts, and safety tooling tries to catch problems afterwards. NornGate is built the other way around. Every action your AI attempts is denied by default — it executes only after passing five deterministic checks, and a failure anywhere in the chain means the action simply doesn't happen. That inversion is what makes unattended AI safe enough to run your business on.

The Baldr problem: why blocklists always lose

In the Norse myth, the god Baldr was made invulnerable when his mother Frigg extracted an oath from every thing in the world not to harm him — fire, water, iron, stone, every plant and beast. She skipped mistletoe. It seemed too young, too small to matter. Baldr died to the one exception nobody listed. Every blocklist-based security model dies the same way.

Default-allow — how most AI tools work

"Allowed, unless we thought to forbid it"

The AI can do anything except what's on the blocklist. Security becomes an endless race to enumerate every dangerous action in advance — every prompt trick, every edge case, every mistletoe. Miss one, and the system fails open: the unlisted action executes. And with AI, the space of unlisted actions is infinite.

one missed exception → breach

Default-deny — how NornGate works

"Forbidden, unless we explicitly allowed it"

Nothing executes without an explicit rule permitting it. There is no blocklist to maintain and no exception to forget, because the unknown is denied by construction. A new attack, a novel prompt injection, an action nobody anticipated — all of it lands in the same bucket: no rule, no execution.

one missing rule → a denied request in a log

Five gates between an AI's intent and your systems

Default-deny is enforced by a pipeline, not a promise. Every side effect — an email sent, an invoice posted, a record updated — transits all five gates in order. Each gate can only pass or refuse; none can be skipped.

G0Ingress
Every request enters through one door, where identity, tenant, and intent are cryptographically bound before any model sees it. There is no side entrance — no path to an agent that doesn't pass G0.
Spoofed requests, cross-tenant access, and anything arriving outside the authenticated channel. Unbound traffic is dropped, not processed.
G1Policy
Deterministic rules — evaluated as code, not judged by a model — decide what this agent may attempt against this system. Default-deny: a rule must exist, or the action doesn't. Every rule change is versioned and itself logged.
The entire class of "the AI did something nobody anticipated." Unanticipated equals unlisted equals denied.
G2Approval
Actions you've flagged as consequential — large payments, contract sends, customer-visible changes — pause for a named human approver. Well-tuned deployments keep this under 5% of all transits: rare enough that approvals get real attention instead of rubber stamps.
Automation of the decisions that should never be automated. And approval fatigue — the quiet failure mode where humans stop reading what they sign.
G3Sandbox
The action executes in isolation first, and its output is verified against a declared contract — the machine-checkable definition of what a correct result looks like. Only verified output moves forward; failures roll back without a trace on your systems.
Hallucinated results reaching production. A wrong total, a malformed record, an off-contract reply — caught in isolation, not in front of your customer.
G4Commit
The verified result lands in your systems and a signed, hash-chained record lands in the ledger simultaneously. G4 is also the only billable event — the platform's economics are aligned with actions that verified, because those are the only ones that pay.
Untraceable actions. If it isn't in the ledger, it didn't commit; if it committed, it's in the ledger. There is no third state.

Rules as code, not a model judging a model

A tempting shortcut in AI safety is to have a second model review the first model's actions. NornGate rejects it for a simple reason: a model policing a model is itself promptable. The manipulation that fools the worker can be crafted to fool the judge — attacker effort scales, your defense doesn't.

G1 policies are evaluated the way mature policy engines evaluate access control: as deterministic code. Same input, same verdict, every single time. Rules are human-readable, versioned, and auditable before the incident — you can answer "what would happen if an agent tried X" without trying X.

Why it matters Deterministic denial is the only defense whose strength doesn't depend on out-thinking the attacker. It doesn't need to be smarter than the prompt — it just needs the rule to not exist.

Policy properties

  • evaluationDeterministic code — never an LLM verdict
  • defaultDeny. No rule, no execution — the unknown is refused
  • auditabilityRules readable and testable before deployment
  • versioningEvery policy change is itself a signed ledger event

Agents hold nothing worth stealing

NornGate agents carry no credentials — not API keys, not passwords, not tokens. They can only request actions; the gateway holds the keys and performs only the requests that survive the gates. Prompt-inject an agent completely and you've gained the ability to ask for things policy already allowed.

This is why prompt injection — the defining unsolved problem of LLM security — changes category on NornGate. Elsewhere it's a breach vector. Here it's a request generator pointed at a wall of rules, and the wall doesn't read persuasion.

Why it matters You cannot exfiltrate a key from a process that never had one. Credential starvation converts your worst-case from "attacker holds our keys" to "attacker filed a denied request."

Key handling

  • agentsZero credentials — request-only, never execute-direct
  • gatewaySole credential holder; performs only gate-approved actions
  • BYOKYour provider keys vaulted at the gateway only — never in agent memory or logs
  • sovereignIAM-role deployments in your cloud; usage attested by signed ledger records, no phone-home

Your data never meets another customer's

Isolation on NornGate is structural, not procedural. Every internal service lives in a realm with its own trust boundary; traffic between realms is mutually authenticated and policy-checked at the mesh, so a compromised component can't move laterally — the mesh refuses the connection before forensics would ever see it.

Isolation extends to the subtle layers most platforms miss: prompt caches are namespaced per tenant, closing the timing side channel where one customer could infer another's prompts from cache-hit latency. Agent memory, knowledge, and ledger partitions are tenant-scoped by construction.

Why it matters Shared-cache timing leaks are the kind of cross-tenant channel that never shows up in a feature comparison and always shows up in a post-mortem. Namespacing removes the channel instead of monitoring it.

Isolation boundaries

  • realmsPer-zone trust boundaries; all inter-realm traffic authenticated at the mesh
  • lateralCross-realm movement is a refused connection, by construction
  • cachePer-tenant prompt-cache namespaces — no timing side channels
  • dataMemory, knowledge, and ledger partitions scoped per tenant

An audit trail that can't be edited — and can still forget

Every gate verdict and every commit is written to an append-only ledger: signed and hash-chained, so any tampering breaks the chain visibly. "Prove what your AI did last quarter" stops being an engineering project and becomes a query — for you, and for your auditor.

The ledger resolves the classic conflict between immutability and privacy law: hashes are anchored immutably; payloads stay erasable. A GDPR Article 17 erasure request destroys the record's content while the chain's integrity — the proof that the action occurred and passed its gates — survives intact. You keep your audit trail and honor the right to be forgotten, simultaneously.

Why it matters An audit trail you can edit is an anecdote; an audit trail you can't erase from is a GDPR liability. Splitting hash from payload is the only design that satisfies both, and it has to be built in from day one — it can't be retrofitted.

Ledger guarantees

  • integritySigned, hash-chained — tampering is self-evident
  • coverageEvery verdict, every commit, every policy change
  • GDPRHashes immutable, payloads erasable — Art. 17 compatible
  • billingInvoices are ledger queries — every line item independently verifiable

Security questions, answered straight

What does fail-closed mean?

Fail-closed means every action is denied by default. An AI agent's action executes only if an explicit rule allows it and every verification step passes — if a rule is missing, a check fails, or a component errors, the action does not happen. The opposite model, fail-open, lets actions through unless something catches them.

Why doesn't NornGate use an AI model to police its AI agents?

Because a model policing a model is itself promptable — the same manipulation that fools the worker can fool the judge. NornGate's policies are evaluated as deterministic code: the same input produces the same verdict every time, and the rules can be audited before an incident, not after.

What happens if an AI agent is manipulated by a malicious prompt?

Very little. NornGate agents hold no credentials and cannot execute anything directly — they can only request actions, and every request is checked against your rules before it runs. A manipulated agent can ask for anything and receive only what policy already allowed. The blast radius is a denied request in a log, not an incident.

Is NornGate's action ledger compatible with GDPR?

Yes, by design. The ledger anchors cryptographic hashes immutably while keeping the underlying payloads erasable. When an erasure request arrives under GDPR Article 17, the record's content is destroyed while the proof that the action occurred and passed its checks remains intact.

Bring your hardest "what if" — we'll trace it through the gates.

Pick the scenario that keeps you from trusting AI unattended: the rogue payment, the leaked record, the manipulated agent. We'll walk it gate by gate and show you exactly where it dies.