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.
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
- Overview — the problem Keep solves and its architectural assumptions.
- SDK reference —
@k9o/moatand@k9o/barbicanin full. - Delivery modes — the three modes and the graduation path.
- API reference — the hosted endpoints.