Skip to main content

Keep Standalone Onboarding

Keep ships either composed into a Kilimanjaro plan via @k9o/core or standalone, in front of any backend and any model you bring. This page is the standalone path: no account, no Kilimanjaro plan, no sign-up required to get Edge Filtration running.

1. Install​

npm install @k9o/barbican

Moat (system-prompt pinning and input and output schema checks) is a local class in @k9o/core — see SDK reference §3. Start with Barbican and add Moat later without restructuring your call sites — the two are designed to compose, not to depend on each other.

2. Gate your first call​

The minimal Edge Filtration flow is: inspect input before it reaches your model, filter output before it reaches your user.

User messageinputinspectinput before modelnot denyYour modelany backendOutput filterredacts outputredacted text returneddenyBlockedthrows with the reason
Barbican runs on both sides of your model call, entirely client-side.
import { Barbican } from "@k9o/barbican";

const barbican = new Barbican();
await barbican.loadBundledBaseline();

async function callAgent(userMessage: string) {
const verdict = await barbican.inspect(userMessage); // decision: "allow" | "deny" | "suspect"
if (verdict.decision === "deny") {
throw new Error(`Blocked: ${verdict.reason}`);
}

const modelResponse = await yourModelCall(userMessage);

const filter = await barbican.createOutputFilter();
return filter.push(modelResponse) + filter.finish(); // redacted text
}

That's the whole Edge Filtration wedge — client-side, free, no network hop, no account. See SDK reference for the full API, and Delivery modes §1 for what it does and does not protect against.

3. Graduate to Semantic Classification​

When you need to catch paraphrased or novel attacks Barbican's pattern-matching can't see, add a call to the hosted classifier — this is where you first need a Kilimanjaro account, since the call is a hosted API:

const classification = await fetch(
`https://<orgSlug>.api.k9o.io/@<projectSlug>/rampart/classify`,
{
method: "POST",
headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
body: JSON.stringify({ input: { text: userMessage } }),
}
).then((r) => r.json());

Sign up at kilimanjaro.dev/keep to get an org slug, project slug, and API key. See API reference §1 for the full request/response contract.

4. Graduate to the Enforced Boundary​

The Enforced Boundary is available two ways. Route your agent's tool calls through Warden over the inbound MCP façade — POST /@<projectSlug>/mcp — and any agent framework (LangGraph, CrewAI, a custom stack) gets policy adjudication, credential brokerage, and a signed receipt per call, wherever your agent runs. See Audit & receipts for the receipt contract.

Running your agent inside the sealed sandbox Kilimanjaro Core runs it in — built on Firelock, the open-source execution shell Kilimanjaro maintains — gives you the strongest guarantee: the sandbox itself has no network path except the single audited vsock egress to Warden, so "sole egress" is a structural property of Firelock's own design, not just an integration discipline — see Architecture §4 for the distinction and Delivery modes §3 for what changes under each path.

5. Pricing on standalone​

Edge Filtration is free and unmetered — nothing about running Barbican (and Moat) client-side incurs cost. Semantic Classification and the Enforced Boundary meter as described in Billing & the GOPS model; current tier rates live on the pricing page.

6. Bundling into a Kilimanjaro plan later​

If you later adopt the rest of Kilimanjaro, Keep composes into your plan the same way Kibo and Gate do — via @k9o/core, with the identical SDK shape you already wrote against. The upgrade is a plan change, not a rewrite of your Keep integration.

7. See also​