One account, a separate brain per client — with no crossover.
Isolated cores let agencies and multi-tenant SaaS give every client a fully separate memory and identity, without standing up separate infrastructure.
A way to give every client or tenant a fully separate AI brain — its own memory, voice, and rules — from a single account, with no per-client stack to run.
If you serve many clients from one AI product, their context must never mix — but running a separate stack per client is expensive, and generic memory tools pool everything together. You need hard isolation without hard operational cost.
What changes with a memory layer.
- Isolation
Generic memory pools every tenant together.
- Identity
One voice and one policy for every client.
- Infrastructure
A separate stack per client to stand up and maintain.
- Margin
Token markup eats into your margin.
- Isolation
Isolated cores — no crossover between clients.
- Identity
A distinct constitution per client.
- Infrastructure
One account; cores selected per request.
- Margin
Bring your own model — no markup from us.
The same loop — three calls, your model in the middle.
prepare
Builds the brief — memory + written identity + coherence gate. No LLM call.
your model
You call your own model — your provider, your key. Khwan never touches it.
record
Persists the turn and learns from it — so the next prepare is sharper.
Every run compounds. The brief gets tighter, cost drops, and answers sharpen — the memory that thinks, not just recalls.
Hard isolation, one line
Each client or tenant is an isolated core — its own memory, its own identity — selected per request. Memory never crosses between cores, so one client can never see another's context.
Per-client identity
Give each core its own constitution so the agent speaks in each client's voice and rules. The coherence gate enforces it, so brand and policy stay separate even from one shared codebase.
White-label economics
You bring the model and keep your margin — Khwan never meters or marks up model tokens. Synthesis compounds each client's brain independently, so quality rises without per-client engineering.
Outcomes, not orchestration.
- Guaranteed no memory crossover between tenants
- A distinct voice and policy per client
- No separate infrastructure per client to maintain
- On-prem / single-tenant available for regulated clients
Agencies, white-label AI builders, and multi-tenant SaaS platforms.
The whole integration — three calls
import { Khwan } from "@khwan/client";
const kw = new Khwan({ apiKey: process.env.KHWAN_API_KEY });
// 1 — Khwan builds the context (memory + coherence). No LLM call.
const turn = await kw.prepare(input);
// 2 — You call your own model. Your provider, your key.
const answer = await yourModel(turn.messages);
// 3 — Hand it back. Khwan persists + learns; next prepare is sharper.
await kw.record(turn, answer);