The intelligence layer
Point us at your own provider key. You pay them their price, directly — never marked up, never resold. What you're paying for is the layer around every call: memory that persists, knowledge that accumulates, retrieval that sharpens the longer a key runs.
The roster
Every seat sits behind the same key and the same accumulated context — switch models mid-conversation and the thread does not notice. Pick by what the turn needs, not by which key you happened to paste in.
Every model runs on your own provider credential. You pay them their price, directly — we never mark it up and never resell it.
The part nobody else sells
A key is never just a credential. It's where one part of your product accumulates what it knows — and what it learns never crosses into another key's context, by construction.
Point one key at your support inbox and another at your changelog, and they stop being two calls to the same stateless model. They become two different, independently smart things. Switch which model answers a key's thread at any time — the memory travels with the key, never the model.
tk_live_a3f2…
support-inbox-key
tk_live_9c71…
changelog-key
tk_live_04be…
onboarding-key
18 months deep
6 months deep
3 weeks deep
Same five models behind every key. Eighteen months, six months, three weeks — three different intelligences, because they were used differently.
“Generate as many API keys as you need for different parts of your app you want to make independently intelligent.”
Bring your own key
You pay the model provider directly, at their price. What you pay us is the layer wrapped around the call — and that layer never needs to hand your key back to anyone, including you.
Your provider charges you for the tokens they serve, at their price. We never mark it up and never take a cut — BYOK usage is metered separately from anything you owe us, and carries no rate at all on our side.
A credential goes into the vault and what we keep is a reference to it. There is no endpoint that returns the value — not to your own session, not to an admin. The keys page can tell you a provider is connected and when it was last proven good; it cannot show you the secret.
A key is authenticated against the provider before storage. If they reject it we refuse to save it and say so; if the provider is unreachable we refuse too, rather than storing something unverified that would fail later inside a conversation.
Delete the credential and the reference goes with it. Deleting your account deletes every stored credential as part of the teardown, and tells you what it removed.
What happens to every call
This is the difference between an API key and a mind. The model you picked writes the answer; everything around it is what the subscription pays for.
A local classifier reads the turn first and decides what kind of request it is. It runs on our own CPU, in milliseconds, before any model is paid for.
Anything that needs more than a direct answer gets a plan — the steps, and the boundary of what may be done without asking you first.
The turn is answered against what this key already knows: past conversation, distilled knowledge objects, and any files you attached to the key — retrieved by meaning, not by recency.
A safety pass runs on the way out. It is the last stage rather than the first, so it judges what would actually be said to you.
What the subscription buys
The tokens are your provider's business — you see them on your own invoice. The subscription pays for everything that happens around them.
Every session adds to what a key knows. Nothing is forgotten between calls and nothing is summarized away — memory only strengthens or fades, it never resets.
The layer distills durable facts out of a key's conversations, so the tenth call already knows what the first nine established.
Every call searches everything the key has seen and pulls in what's actually relevant — not just the last few messages, not a blind context dump.
Move a key from one model to another mid-project. The memory, the knowledge, and the thread all come with it.
One honest disclosure: retrieving and assembling context adds tokens to every request your key sends — tokens your provider bills you for. We tell you exactly how many we added, on every message and in aggregate. What we don't publish is how we assembled them. The structure is ours.
Pricing
The quota is the layer, not the tokens — switch between all five models freely, inside the same monthly count. Lower-cost regions get automatically lower pricing at checkout.