Delivery modes
Keep — the AI Trust, Risk and Security Management (AI TRiSM) Layer, a Gartner-defined category — deploys its four layers in three modes. You pick the mode that matches how much you need Keep to be advice versus how much you need it to be a boundary, and you move between them without rewriting your integration.
The mode names describe what the deployment does. There is no "Mode A / B / C" — a mode is named for its function.
1. Edge Filtration
| Layers | Runs | Promise |
|---|---|---|
| Moat + Barbican | Client-side, in your process | Deterministic first line of defense |
Edge Filtration is the free, client-side floor. You install the SDK, wrap your model call, and every request passes through prompt pinning, input-schema validation, normalization, and pattern matching before it reaches the model — and output passes back through filtering and PII redaction on the way out.
It is deterministic and cheap, it adds no network hop, and it works in front of any model. It is defense-in-depth: it raises the cost of an attack and catches the known-shape ones. It does not, on its own, make an action structurally impossible — that is what the Enforced Boundary is for.
Fits well
A prototype or an internal tool where the primary need is a cheap, zero-latency-hop backstop against known attack shapes — no account, no hosted dependency, nothing to provision.
Doesn't fit well by itself
Any agent that reads content an adversary could plausibly have written (the open web, inbound email, a public form) — Barbican catches known-shape attacks, not paraphrased or genuinely novel ones. Pair with Semantic Classification for that.
2. Semantic Classification
| Layers | Runs | Promise |
|---|---|---|
| Rampart | Hosted API | Advisory intent scoring |
Semantic Classification adds the hosted classifier. Your integration sends input (and, where you want it, output) to POST /rampart/classify and receives an intent score for injection, jailbreak, and exfiltration framing — the attacks a pattern-matcher cannot see because they never match a fixed string.
This mode is probabilistic and advisory. The classifier has a measured error rate, it runs fail-closed, and it is meant to sit behind Edge Filtration, not replace it. It sharpens your picture of intent; it informs a decision rather than being the boundary that enforces one.
Fits well
RAG over untrusted or user-supplied content, email/ticket-triage agents, anything summarizing or acting on text you did not author yourself — the class of attack where the payload is prose, not a fixed string.
Doesn't fit well by itself
Anything where a false negative has an irreversible consequence. A probabilistic classifier that's usually right is still the wrong sole gate in front of an action you cannot undo — that's what the Enforced Boundary is for.
3. Enforced Boundary
| Layers | Runs | Promise |
|---|---|---|
| Warden | Standalone over MCP, or platform-native inside Kilimanjaro Core | Enforced adjudication; a structural sole-egress guarantee on the platform-native path |
Enforced Boundary is the mode where Keep stops being advice and becomes a wall: at decide-time, a tool call is validated against its manifest schema, checked against its granted scope, and subjected to approval or maker-checker where required; at execute-time, RLS filters what the action can actually touch; and every decision is recorded in a signed, tamper-evident record.
Warden reaches this mode two ways:
- Standalone, over the inbound MCP façade (
POST /@<projectSlug>/mcp) — govern and broker tool calls from any agent framework, wherever your agent runs, without relocating it. - Platform-native, inside the sealed sandbox Kilimanjaro Core runs each agent in — built on Firelock, the open-source execution shell Kilimanjaro maintains. The sandbox itself has no network path except the single audited vsock egress to Warden, so Warden is the sole egress as a structural property of Firelock's own design, not an integration discipline Kilimanjaro Core layers on top.
The un-bypassable claim attaches to the platform-native path specifically, and it carries it precisely: the residual risk there is a measured adversarial bypass-rate published from a red-team harness, not an asserted zero. The standalone path gives you the same adjudication, brokerage, and signed receipt on every call your integration routes through it, without that sandbox-level guarantee against a call that skips Warden entirely.
Fits well
Agents with real tool access — anything that writes, deletes, sends money, or calls a third-party API on your behalf. Also fits any deployment where a compliance or security review requires a signed, tamper-evident record of every consequential decision, not just the ones a developer remembered to log.
Requires
An MCP-routed integration for the standalone path, or running inside Kilimanjaro Core for the platform-native path — see Architecture §4 for what each guarantees.
4. The graduation path
The three modes are a graduation, and the graduation is a configuration change — not a rewrite.
| From | To | What changes in your code |
|---|---|---|
| Edge Filtration | Semantic Classification | Point the SDK at the hosted classifier; call sites unchanged |
| Semantic Classification | Enforced Boundary | Route gated actions through Warden — over MCP or in Core; call sites unchanged |
Because the SDK shape is identical across modes, moving from the free client-side floor to the hosted classifier to the enforced boundary swaps the host your SDK talks to and leaves your call sites in place. You do not re-architect to get stronger guarantees — you reconfigure. This is the same zero-rewrite contract the rest of the Kilimanjaro stack holds to.
A team typically graduates mode by mode as an agent's blast radius grows: ship read-only with Edge Filtration, add Semantic Classification once the agent starts reading untrusted content, move to the Enforced Boundary the day the agent gets its first write- or send-capable tool. Nothing about that sequence requires re-plumbing the integration each step — only the deployment configuration changes.
5. Choosing a mode
- Start with Edge Filtration on day one — it is free, it is deterministic, and there is no reason not to.
- Add Semantic Classification when you need to catch paraphrased attacks that pattern-matching misses.
- Move to the Enforced Boundary when "we advised against it" is not good enough — when an action must be structurally impossible, not merely discouraged, and you need a signed, tamper-evident record that it was gated.
A useful test: can this agent's next action be undone? If every action is a read, or a write you could freely reverse, the advisory modes are proportionate. The moment an agent can send money, delete data, or call an external system with side effects you cannot take back, that action belongs behind the Enforced Boundary — even if the rest of the agent stays on the advisory modes.
6. See also
- Keep — overview — the problem Keep solves and the claim boundary.
- Architecture — the four layers — Moat, Barbican, Rampart, Warden in depth.
- Onboarding — start with Edge Filtration in minutes.
- API reference — the
/rampart/classifycontract.