Your AI answers only from what you approved.
ContextBus grounds, gates and accounts for every answer your product gives, so the people responsible for it can stand behind it.
Reviewed knowledge, rules on every call, a prompt injection guard on every answer, and models that earn the right to write. Plugs into Copilot, Slack, your website or any tool that speaks the OpenAI protocol. Run for you by ContextBus LLC.
The console your team works in: knowledge, rules, runs, models and suggestions in one place.
Answers only from approved content
Every document is versioned and reviewed before it can inform an answer. Content filed for one purpose never grounds another.
Every model earns the right to write
A model passes your test pack before it drafts a word. Your admin can approve or block any model at any time.
Every call scored, traced and accounted for
Tokens, cost and usage by provider and model. Every answer traces back to the content it used.
Control over what your product says, without slowing it down.
Six things your team gets on day one, all from one console.
Reviewed knowledge
Documents are versioned and reviewed before they go live. Retrieval is scoped by purpose, so a document filed for one use never grounds another.
Rules on every call
Do and don't rules ride along on every call your product makes. Add one in the console and it applies at once.
A grounding check
Any number, name, date or link that was not in the approved content is flagged. The same checks run on your test packs, with the same result every time.
Model clearance
A model must pass before it may write. An admin can approve a trusted model or block one outright.
Cost and lineage
Tokens by provider and model, cost per call, usage over time. Trace any answer back to the content it used.
Suggestions you approve
The engine reviews what your team did with drafts and proposes better rules and knowledge. Nothing applies until a person says yes.
One console for everyone who is accountable for the answer.
Your product can open it straight from its own pages.
One governed answer, behind whatever door your users already use.
Describe the assistant once. Put it in Copilot, a website, Slack, your own app or any tool that speaks the OpenAI protocol. Every door gets the same approved knowledge, the same rules, the same guard and the same receipt.
Any OpenAI compatible tool
Point Open WebUI, LibreChat, Continue, LangChain or a no code builder at /v1/chat/completions with your key. A base URL change, nothing else. Streaming included.
Copilot Studio, VS Code, Claude
The bus is a tool in any host that speaks the Model Context Protocol, and an OpenAPI plugin for Copilot Studio. Ask, search, list what is approved.
Your website
One script tag puts a chat panel on any page, on a public key bound to your domains and rate limited per visitor. Visitors get the answer and the sources, never the machinery.
Actions your host performs
Build a repeatable pattern once in the console: its purpose, inputs, grounding, rules, steps and policy. Say "run cut-release" in Claude Code, Copilot or your product; the bus grounds it, gates it, hands the host the steps and records what it reports back. Irreversible steps wait for a person. The bus never executes.
Your own product
Call /chat directly, or use the Python and JavaScript clients and the cbus command line. Signed webhooks tell your product when an answer was flagged or a document changed.
- Describe the assistant in one file
Which spaces it may read, its do and don't rules, where its documents come from, which model, which doors, its caps and its webhooks. Send it to
/appsand the bus builds it: a key per door, caps on each key, the rules, the subscriptions, the connectors. - Let the documents come to it
A connector crawls your help centre or pulls a folder on a schedule. Every page arrives as a proposed version a person approves; a page that changed supersedes the old one; a page carrying instructions aimed at the model is never approved automatically.
- Get the answer, with the receipt
The answer comes back with what it was grounded in, what the guard and the scorer found, and what the call cost. Your app shows the answer; you keep the trail.
// the whole assistant, described once POST /apps { "app": "acme-support", "namespaces": ["acme/support", "acme/policies"], "rules": { "pack": "support-v3" }, "sources": [{ "connector": "web", "start": "https://acme.example/help", "approval": "reviewer" }], "model": { "provider": "anthropic", "model": "claude-sonnet-5", "clearance": "required" }, "surfaces": ["openai", "mcp", "web-widget"], "caps": { "answers_per_day": 5000, "spend_usd_month": 400 }, "webhooks": { "answer.flagged": "https://acme.example/hooks/cb" }, "identity": { "passthrough": true, "acl": "source" } } // then, from any tool that speaks OpenAI POST /v1/chat/completions Bearer acme-support:openai { "model": "auto", "messages": [{ "role": "user", "content": "Can I pause my plan?" }] } // the answer carries its receipt { "choices": [{ "message": { "content": "Yes. A plan pauses for up to 90 days..." } }], "contextbus": { "passages": ["Billing policy"], "findings": [], "clean": true, "cost_usd": 0.0021 } }
Python and JavaScript clients, the cbus command line, signed webhooks, a web crawler connector and the widget ship with the bus today. Drive, SharePoint and Notion connectors and the Teams and Slack adapters follow on the same contract.
A prompt injection guard, signed identities, and doors that cannot be pried open.
The documents your assistant reads were written by other people. The questions come from strangers. The bus treats both as data and checks what comes back before your product shows it.
Passages are data, never instructions
Every retrieved passage is rendered inside document tags with a standing instruction the model is held to: third party text is reference material, never a command. Hidden characters and control characters are stripped on the way in.
Injection is caught on the way in
"Ignore previous instructions", role markers, chat template tokens, tool call mimicry, zero width text, base64 blobs, homoglyphs and exfiltration links are named as findings. Flag by default; block mode refuses before the model ever runs.
Leaks are caught on the way out
An answer that quotes your rules verbatim, invents a link that was not in the context, contains a secret shaped string or a markdown image is flagged, and withheld in block mode.
Who is asking travels with the call
Your app signs the end user into every request. A document can name the users and groups allowed to read it; retrieval filters by that signature, and an anonymous visitor never sees a restricted source.
Keys, caps and origins
A key opens only its spaces. Every key carries a rate limit and a monthly cap. A website key is bound to your domains and rate limited per visitor, and returns the answer and the source titles only.
A run, not a call, is what gets governed
One question in a coding agent becomes many tool calls. Every call under a run counts against budgets for calls, actions, spend and time; the same call three times stops the run; a stopped run tells the host why in one sentence; every run leaves a receipt.
Signed webhooks, no private networks
Every event out is signed with a per subscription secret and a timestamp; deliveries go to HTTPS only and never to a private address. Crawled pages are read through the same guard, and a page that tries to instruct the model is never approved automatically.
Ask the widget something ordinary, then try to break it.
This panel is a simulation of the embeddable widget with three canned answers, so the page needs no server. On a real bus the same panel talks to /widget/chat on your public key.
ContextBus is in private beta.
We are working with a small number of teams while the billing and sign up are finished. Pricing is not published during the beta, and nothing is charged. Invited teams are told what it will cost before anything is.
If you are building something that needs governed context, tell us about it and we will send you an invitation.
Request an invitationBetween your product and the model, on every call.
Your product asks. ContextBus grounds the question, applies your rules, and hands back an answer it can account for.
Your product
Keeps its own pages and its own experience. It asks ContextBus and gets an answer it can show with confidence.
ContextBus
Brings the approved knowledge and your rules to the question, checks the answer, and records what it cost and where it came from.
The model
Bring your own key for the model you trust, or a model of your own. Anthropic today, more providers on the same seam, and every model earns the right to write before it does.
Teams whose AI speaks for the company.
- Builders shipping an assistant that answers customers in the company's name.
- Products in careful industries, where every claim has to come from somewhere.
- Teams that need to show the cost and the trail behind every answer.
Run for you, secured end to end.
ContextBus LLC runs it, secures it and keeps it current, so your team works on the product and not the plumbing.
Served securely and traced end to end. Ask us about the setup that fits your product.
- Your content and your data stay yours.
- Keys bound to your own spaces, so a key opens only what it should.
- Updates delivered by us, with no work on your side.
- The model is your choice: your own key, a provider we support, or a model you run.
The first product on the bus.
Terry, the compliance-first AI sales rep from the same company, is the first product built on ContextBus. Every message Terry drafts is grounded in reviewed knowledge, bound by the team's rules and checked before it goes out, and the console you see above is the one Terry's teams open from their own pages.
Meet TerrySee ContextBus on your own content.
Tell us what your product needs to say and we will walk you through the console on your material.