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.”
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.