Add AI to your productwithout buildingretrieval.
Oberik is the agent layer you drop into your SaaS. Each of your customers gets answers grounded in their own documents — with the page and the quote — plus tools, a real Linux computer, memory and scheduled work. Isolation, permissions and per-customer cost come with it.
import { createClient } from "@oberik/sdk";
// Your backend mints a token scoped to ONE end-user.
// Nothing it doesn't list can be reached — not even
// by a tool the model decides to call.
const mint = async () => {
const r = await fetch("/api/ai-token", { method: "POST" });
return (await r.json()).access_token;
};
const ai = createClient({ getToken: mint });
// Ask over that user's own documents.
const res = await ai.chat.send({
message: "How did Q3 revenue trend, and why?",
tags: ["finance"],
});
res.content; // grounded answer
res.citations; // document · page · quote
// Or stream it straight into your UI:
ai.chat.stream(
{ message: input, tags: ["finance"] },
{ onToken: (delta, full) => render(full),
onCitations: (cites) => showSources(cites) },
);
Q3 revenue grew 24% quarter over quarter, driven mostly by EMEA renewals. Net retention improved to 112%.
Answer, citations and files — scoped to this one user, billed to this one customer.
Bring your own provider keys — any model your customers want
The model is a line of code.
Everything around it isn’t.
Six problems stand between a demo and something you can put in front of paying customers. Each one is a quarter of engineering. All six ship on day one.
If you build it: Row-level tenancy, per-tenant vector namespaces, object prefixes, and an audit story you can defend.
With Oberik: A project is a tenant. Isolation is enforced in the data plane, not in your query code.
If you build it: Chunking, embeddings, reranking, citation spans, and a reindex every time you change a model.
With Oberik: Upload anything. Answers come back with document, page and quote, or they don't come back.
If you build it: A permission system the model can't talk its way past — and that still holds when it calls a tool.
With Oberik: Capability-scoped tokens. Anything the token doesn't list is refused before the tool runs.
If you build it: Sandboxes, file I/O, timeouts, egress rules, idle reaping, and cleanup that never quite works.
With Oberik: A Linux microVM per conversation. It sleeps when idle and wakes where it left off.
If you build it: Queues, retries, DST-safe cron, dead-letters, signed webhooks, and restarts that lose jobs.
With Oberik: Durable one-shot and recurring runs, delivered into the chat session or a signed webhook.
If you build it: Token accounting per user, per model, per customer — stitched from provider invoices after the fact.
With Oberik: Spend, latency and full traces, sliced per project and per end-user, as the calls happen.
Your customer asks. The agent does the work.
Not a chatbot bolted onto a help centre. A question typed into your product, answered from that customer's own data — and acted on when an answer isn't the point.
“Which of our vendor contracts auto-renew before March?”
Retrieval runs over that customer's contracts only, and every claim comes back with the clause, the page and the quote it came from.
“Clean this export and chart revenue by region.”
The agent pulls the file into a sandbox, writes and runs the Python, and hands back a PNG your user downloads from your UI.
“Every Monday, summarise new filings and flag what changed.”
A durable schedule survives your deploys, remembers what it already reported, and delivers into the chat session or a signed webhook.
Everything an agent needs, governed
A data plane that does the hard parts, and a control plane that decides who is allowed to do what — per project, per token, per request.
Answers you can defend
Upload anything; get back document, page and quote for every claim. Layout-aware parsing, OCR only for the pages that need it, versioned reindex.
Tools, yours and theirs
Your own functions, HTTPS endpoints the agent calls server-side, and any MCP server you or your customer connects — all behind the same authorization.
Memory that carries over
Atomic facts and curated wiki pages that survive the session, so it stops rediscovering the same context on every turn.
Work that outlives the request
Cron and one-shot runs that survive restarts — signed webhook delivery, retries, dead-lettering, DST-safe timezones.
Cost you can bill back
Spend, latency and full request traces in one place, sliced per project and per end-user — so a customer's usage is a number, not an estimate.
Guardrails that hold
Prompt-injection and PII screening, cite-or-refuse groundedness — enforced server-side, so a client cannot switch them off.
Give your agent a computer
Not just answers — work. It runs commands, edits files, installs what it needs, and hands results back as downloads. Your user watches every step over the same stream that carries the tokens.
- A Linux microVM per conversation — nothing shared, nothing to configure
- Workspaces persist across turns, sleep when idle, wake mid-thought
- Files both ways: your user's upload in, the agent's result out
- No network unless you allow it; every command bounded and audited
You decide what each customer can do
Toggle capabilities per project. The control plane mints tokens bounded to exactly those permissions, and the data plane refuses anything outside them — the model cannot escalate. Try it:
{ "tenant_id": "9c4e1f2a-…", "sub": "acme:eu:ana", "capabilities": ["chat","documents:read","documents:write","computer", ], "max_tool_iterations": null }
Every customer, fully isolated
One deployment, many companies. Each project maps to its own tenant — separate rows, vectors, objects, credentials, and spend. No shared state, no leakage, nothing for your query code to get wrong.
- Separate documents, embeddings, and files for every customer
- Capability-scoped JWTs the data plane enforces on every call
- Hierarchical visibility scopes — org, team, or a single end-user
Live in an afternoon
Three steps between an empty dashboard and a grounded answer streaming into your own product.
Create a project
One project per customer. Each provisions an isolated tenant — its own documents, vectors, storage, credentials and spend.
Set the ceiling
Toggle capabilities, paste your LLM keys, connect MCP servers, set spend caps. This is the maximum any token may hand out.
Mint tokens & ship
Your backend mints a capability-scoped JWT per end-user. Call the SDK; stream answers with citations into your UI.
Two calls, and it's in your product
Your server decides what an end-user may do; your app streams the answer. The permissions ride in the token, so your frontend never holds anything privileged.
// your server — decides what this user may do
import { createProjectClient } from "@oberik/sdk";
const oberik = createProjectClient({
projectId: process.env.OBERIK_PROJECT_ID,
projectKey: process.env.OBERIK_KEY, // pk_… — server only
});
// Narrowed to one end-user, and to what they may see.
const { access_token } = await oberik.tokens.mint({
subject: `${org.id}:${team.id}:${user.id}`,
scope: `${org.id}:${team.id}`,
capabilities: ["chat", "documents:read"],
expiresIn: 900,
});// your app — streams the answer
import { createClient } from "@oberik/sdk";
// getToken is called again when a token expires,
// so the request is replayed, not failed.
const ai = createClient({ getToken });
ai.chat.stream(
{ message: input, tags: ["finance"] },
{ onToken: (delta, full) => render(full),
onCitations: (cites) => showSources(cites),
onAttachments: (files) => showDownloads(files) },
);Nothing privileged client-side
Tokens are minted server-side and expire. Your provider keys never leave your project.
One API, every customer
The same endpoints serve every tenant; isolation is enforced on our side, not yours.
Streaming that survives drops
Reconnect and the stream resumes where it left off — generation keeps running regardless.
Your keys, your models, your bill
Oberik doesn't sit between your customers and their vendors. Per project, plug in your own provider keys, MCP servers, retrieval and OCR models, and spend caps. Requests route through those credentials, so the usage is billed to you at your provider's price — never resold.
- Any model from any provider — swap without touching code
- Per-tenant MCP servers loaded straight into the agent
- Spend caps and rate limits enforced on every key
Free while we launch. Bring your own keys.
You already pay a model provider. Keep paying them, at their price, on your account — the traffic routes through your credentials. Oberik itself costs nothing while we're launching.
+ whatever your provider charges
No credit card, no seat count, no usage meter of ours to watch. When the free period ends you'll hear it from us first — nothing starts charging on its own.
- Every capability — retrieval, tools, sandbox, memory, scheduling, guardrails
- As many projects as you have customers
- Per-customer cost, latency and traces
- The typed SDK, the dashboard, and the docs
- Your own provider keys, MCP servers and models
Before you sign up
What does it actually cost?
Which models can I use?
How are my customers kept apart?
acme:finance:ana) bounds which data one end-user can see.Can the model give itself more permissions?
Do I have to rewrite my product?
I don't want to write the integration. Can my coding agent do it?
ssh ssh.oberik.com is the whole dashboard as text: sign up, create a project, set the ceiling, upload documents, mint tokens, read the docs. An agent with a shell needs no browser to configure Oberik for your project.ssh ssh.oberik.com 'login link' # a URL for you to approve ssh ssh.oberik.com 'docs' # the whole product, as text ssh ssh.oberik.com 'discover' # every command, as JSONThe commands are generated from the control plane's own route descriptions at connect time, so there is no CLI to fall behind the dashboard. Oberik over SSH →
Didn’t answer it? Email us.
We’re a small team and we read everything. A bug, a feature you need, a hand with your integration — or just tell us what you’re building. All of it is welcome, and a person answers.
hello@oberik.comOr read the whole API first — the docs need no signup.
Ship your first agent today
Create a project, paste your provider key, mint a scoped token. Your first grounded answer in minutes — and free while we launch.
No credit card · Your own provider keys · Free for a limited time
Rather talk to someone first? hello@oberik.com