AI governance
Your workspace is always named. Your customers never are.
Every AI call in Oneop takes the same path before it reaches a model: the text is scrubbed of personal data, screened for manipulation, attributed to your workspace and charged against your allowance — in that order, and with no way round it.
What this page will not do is pretend one switch governs everything. The controls that are absolute sit on the action itself. Where a boundary differs between the chatbot, an agent and an automation, we show you the difference instead of averaging it into a promise.
Every control on this page is on the free plan.
1
model provider your prompts ever reach
2
controls with no setting anywhere that turns them off
3
billing identities kept apart — yours, the public demo’s, and ours
402
the code at your ceiling once hard enforcement is on, not a larger invoice
0
money or stock actions available until you switch them on
Know who is asking. Define what AI may do. Limit what it may spend. Control how it acts. Keep what happened.
Five questions, and they are not equally answered. Two have one answer that holds everywhere. Two differ by surface. The fifth has a gap in it we would rather name.
- IdentityThree principals that never share an identity: your workspace, the public demo on this website, and our own internal automation. What varies by surface is how strongly the person behind a call is known — a real difference, not a rounding error.
- AuthorityFour classes: read something, prepare something for a person, act on your business, or refuse. Refusal is the only one that behaves identically everywhere.
- SpendOne path into a model, weights per kind of action, an atomic reservation that has to fit before the call starts, and a refund when the model produces nothing.
- ExecutionStarted by a person, by an event, or by a clock — depending on the surface. Ceilings that end a run rather than extend it. And no exactly-once promise, because it would not be true.
- EvidenceSpend recorded before the work, outcome recorded after it, and refusals not yet recorded at all. Three states, said plainly.
Redact
Personal data out of the prompt — and out of the copy we keepScreen
Manipulation patterns refused before a provider is called or a credit reservedAttribute
The workspace resolved before anything is generatedReserve
The weight charged atomically, and it has to fit what is leftGenerate
The model chain runs, and which model served it is recordedSettle
Tokens and cost written back — or the whole reservation refunded
Three principals that never borrow each other’s identity
The usual failure here is an implicit one — internal automation quietly billed to “some tenant”, public traffic spending against a customer’s pool, and afterwards no number that can be reasoned about on its own. Oneop keeps three apart deliberately.
Your workspace
Your allowance. Your ledger. Your records.
Every AI call your product makes is charged here and recorded here. The workspace is resolved on our side from the credential the call arrived on — never from anything a browser, a page or a message can set.
The public demo
Anonymous, and capped whatever else is switched on.
The assistant on this website has no account behind it, so it gets its own principal and its own ceiling — and that ceiling holds regardless of whether billing enforcement is on anywhere else. Strangers cannot run up a customer’s tab.
Us
Billed like a customer. Refuses to run unbilled.
Oneop’s own internal agents have a principal, a budget and a ceiling of their own. If that principal is not there, they do not fall back to a convenient workspace — they stop. An internal agent that cannot be billed should not run.
One thing to hold onto as you read the rest: a principal is not a person.A signed-in member of staff, a customer who has proved an email address, and a scheduled job all resolve to the same workspace, and they are not equally identified. Where that difference matters — a customer-facing chatbot touching a record — the surface does its own verification on top. It is not inherited from being attributed.
Four things AI can do to your business, and only one of them behaves the same everywhere
A feature list flattens these into one bullet. They are not one thing: obtaining information, drafting something for a person, changing a record and declining outright carry four different risks and four different authorisation paths. The fourth column is the one worth reading, because that is where authority actually comes from.
The four authority classes
| Class | What it means | Which surfaces | What decides whether it is permitted |
|---|---|---|---|
| Read | Obtains information and changes nothing. | Every AI surface in Oneop. | The set of tools that surface was built with — the boundary is what it can reach, not what it is willing to do. |
| Prepare | Creates something a person still has to action — a draft reply, a queued action, a suggested reorder. | Chatbot, help desk, agents, sequences. | The surface’s own design. Nothing leaves and nothing posts until somebody acts on it. |
| Act | Changes a record or sends something outward. | Agents, automation, the support auto-responder. | An autonomy mode where the surface implements one, and a fixed rule where it does not. See the note below the table — this is the part that is not uniform. |
| Refuse | The call does not happen at all. | Every surface, without exception. | Three unconditional rules: a prompt that trips the injection filter, a money or stock action while those are switched off, and a customer-facing request for a record the visitor has not proved they own. |
The part we will not generalise. Three autonomy modes — suggest, queue for approval, or act — are a feature of AI agents specifically. They are not a platform-wide dial, and a page that presented them as one would be telling you that a chatbot and a scheduled automation have a setting they do not have. Every other surface has a fixed rule instead: what it may do was decided when it was built, and what you change is which tools you gave it and whether an approval step sits in front.
Money and stock are the exception that runs the other way. Those actions are refused at the single point where every action is dispatched, so the refusal survives the most permissive autonomy mode and survives a human approval too — the check sits underneath the approval rather than beside it.
A call has to fit before it starts
AI spend is measured in credits, and the weight depends on the kind of work rather than on the length of the answer. The reservation is taken before the model is called, in a single atomic step, and it has to fit inside what is left of your month. Four credits left and a five-credit action means the action does not begin — you are not charged four and then cut off in the middle of a run.
Where hard enforcement is switched on for the deployment, what happens at the ceiling is a refusal you can see: a 402 with an upgrade message, allowed to travel back to whatever asked for it rather than being caught and dressed up as a technical hiccup. A spend limit that presents as a glitch is one that gets debugged for a week instead of noticed in a minute.
Two things run in your favour underneath. A retry carrying the same key is charged once, not twice. And a call the provider never completed is refunded — the reservation released and the row removed — so you pay for answers rather than for attempts.
See what each plan includes- 1A chatbot reply
- 2A copilot query, or an AI-drafted email
- 3Reading a document with vision
- 5One agent action
- 10An executive insight
Credits, per action. An action we have not classified is charged at the heavier rate rather than the lighter one — deliberately, so a new feature can never be quietly cheaper than the thing it replaced. If a number on your ledger looks wrong for the work, that is worth telling us about.
How an action actually runs, surface by surface
This is the axis where a single claim would be least honest, so here are the differences rather than an average of them.
- Something starts it, and it is not always a personAn agent run is started by one of your people — autonomy governs what happens after that start, not whether the agent starts itself. An automation is started by an event in your data, a chatbot conversation by a visitor, a digest by a clock. Four different answers to “who set this off”, and a different audit question in each case.
- An approval is a row, not a process holding its breathWhen an action needs sign-off it is written to a queue and waits there. Approving it dispatches it inside the same transaction that records the approval, so a failed dispatch rolls the decision back rather than leaving an action marked approved that never happened.
- Ceilings end a run rather than extending itAn agent gets six reasoning steps by default and twelve at the absolute hard cap, a six-thousand-token budget, forty-five seconds of wall clock and three actions. Reaching any of them ends the run and marks it escalated for a person to look at. None of them is a soft target that quietly stretches.
- We do not claim exactly-onceA retry with the same key is deduplicated and charged once. But a longer process that is interrupted and resumed can re-enter the step it stopped in, and not every step is safely repeatable. If a second occurrence would be a problem — a payment, a shipment, a message to a customer — put an approval in front of it rather than relying on a guarantee we are not making.
- Failing closed is the default where it costs you leastMoney and stock actions, a missing internal billing principal, an unverified customer reaching for a record: all refuse. Where failing closed would take a paying customer offline for something that is not their fault — a lookup blip on a platform-wide counter, say — it fails open and raises an alarm instead. Both choices are deliberate, and they point the same way: your workflow keeps running, your data does not move without permission.
Written before, written after, and not written
“Everything is logged” is the easiest sentence on a governance page to write and the hardest to mean. Here is what is actually recorded, in three groups, and the third group is the reason this section exists.
Before the model runs
The credit reservation — your workspace, the kind of work, and its weight — written in the same transaction that charges it. The spend record cannot exist without the workspace on it, and it cannot be charged without the record.
After it returns
An execution record on the success path and the failure path alike: which model actually served the call after any fallback, tokens used, how long it took, and the error text when there was one. A failed call leaves a record that says so.
Not written, today
A refusal. A prompt stopped by the injection filter, or a call stopped at your ceiling, is refused before the record is created — so it reaches your error handling but not your AI history. We would rather you knew that than read an empty history as “nothing was attempted”.
Evidence also differs by surface, and one difference is worth knowing before you design around it: rejecting a queued agent action records the decision, who made it and when, against that action. Rejecting an automation approval does not currently leave an execution record at all. Same word, two different trails — which is exactly why this page shows you the boundaries instead of one summary sentence.
Connected with Oneop
These are not rules about AI. They are rules about your records.
Governance only means something when the thing being governed is real, and in Oneop it is: the AI is reaching into the same tables your staff have open, not a copy synced overnight. That is what makes a boundary like ‘read orders, never change them’ enforceable rather than aspirational — there is exactly one set of orders, and one place to say no. It also explains why this page reads the way it does. A control that only exists in the AI layer would be a setting; a control that sits on the record itself is the same refusal your staff would hit. Every module below is somewhere an AI call can reach, which means every module below is somewhere these five axes already apply.
- Live chatConversations become part of customer context.
- AI chatbotAI responds using permitted business context.
- AI agentsAI acts on the same records people do, under limits that are published rather than described.
- AutomationA trigger in one module can act in another without an integration between them.
The other 7 modules sit on the same record, and reach AI governance the same way:
- CRMCustomer and commercial context follows the work.
- Help deskSupport sees the customer, commercial and operational history.
- SequencesOutreach works from CRM and customer context under controlled automation.
- Project managementSold work becomes delivery without rebuilding customer context.
- Inventory & warehouseSales and operations work from the same product and order context.
- ReportingEvery module is already a reportable dataset, so nothing has to be exported to be measured.
- FinanceOperational transactions continue into financial records.
Beyond the five axes
Redaction happens before the record, not after
The copy of the prompt kept in your AI history is already scrubbed. Email addresses, phone numbers, card-shaped and national-ID-shaped numbers are replaced before the text leaves the process — so the log cannot become the leak.
A call the model never answered is refunded
If the provider produced no output, the reservation is released and the ledger row removed rather than left standing. You are billed for answers, not for attempts.
The demo on this website has its own budget
Public traffic runs as a separate billing identity with its own ceiling, and that ceiling holds whether or not billing enforcement is switched on. Strangers cannot spend against a customer’s allowance.
Our own automation is billed like a customer
The platform’s internal agents have their own principal, their own ceiling, and no fallback. If there is nowhere legitimate to bill them, they refuse to run rather than land in somebody else’s ledger.
Injection screening is a filter, not a boundary
It is pattern-based, folds leetspeak and full-width characters before matching, and runs on every call. It is best-effort by design and we will not describe it otherwise. Do not make it the only thing standing between untrusted text and an action.
A demo run is stored as a demo run
Simulated agent runs make no model call and create no credit row, carry no confidence score rather than a flattering one, and are badged in the run list and the drawer. A demo cannot be mistaken for evidence.
Where your prompts go, and where they stop
One destination. Prompts leave Oneop for Google’s Generative Language API to serve your call, and for nothing else. There is no second provider, no routing between vendors, and no model picker to get wrong — a call asking for something else is still served by Gemini. We do not publish the specific model versions on this page on purpose: they are configuration, they change, and a version number printed on a marketing site is a claim that quietly stops being true.
The integrations below are not places prompts travel to. They are how business records arrive — an order from WooCommerce, a deal from HubSpot, a payment through Stripe, a lead captured on WordPress — and once a record is in Oneop, the same five axes govern what AI may do with it regardless of where it came from. Everything an AI action sends outward is checked before the request is made.
See all integrations- Google Gemini
- Stripe
- WooCommerce
- HubSpot
- WordPress
- Gmail
- Microsoft 365
- SendGrid
For the technical evaluator
Nobody can add an AI feature that spends money nobody can trace.
Not a policy, not a review step. A test walks our server source, finds every call into the model router, and fails the build if any one of them does not carry a workspace. At the time of writing that is 115 call sites across 37 files, and all 115 pass.
Why this is the guarantee, and the four limits around it
Why this one, and not a stronger-sounding one. The obvious claim for a governance page is that every billed response is attributed to a workspace before generation. We tested it against the code and it does not hold as a statement about runtime: the refusal of a call that names no workspace lives behind a breaker that ships switched off, so with it off such a call would be served and recorded against nobody. We could have shipped the sentence anyway. What we shipped instead is the half of it that is absolute — and the reason it is absolute is that it is a property of the codebase rather than of a setting. A setting can be off. A build that will not compile cannot be off.
How it is enforced. There is exactly one function through which every AI call in the product reaches a model, and one test that treats that as a law rather than a convention. It reads every file in the server source tree, finds every call into that function by pattern, and inspects the arguments of each — failing if a workspace identifier is absent, and failing equally if one is present but written as undefined, null or zero, which is the shape this kind of check is usually defeated by. A second half of the same test proves no code in the AI surfaces calls the model provider directly, because the cleanest way past a required path is not to take it. Both halves fail the build rather than warning.
The first limit: this is a static check, not a runtime one. It proves the identifier is threaded through to the call. It cannot prove the variable holds a value at the moment the call runs — a caller that legitimately has no workspace can still pass an empty one. Refusing an empty one at runtime is a separate control, and that is the breaker mentioned above, which is armed deliberately rather than by default. If unattributed AI spend is something you need refused outright rather than merely traceable, ask us to arm it for your deployment.
The second limit: it proves attribution, not correctness. The test asserts that a workspace is named. It cannot assert that the workspace named is the right one — that is a tenant-isolation property, enforced at the data layer and tested separately, and it is not what this guarantee is about.
The third limit: it covers our server source. It reads the server tree, which is where every model call in the product lives today. It is not a statement about code that does not exist yet in places it does not look.
The fourth limit: a refusal still leaves no history. As §4.5 says plainly — a call stopped by the injection filter or at your ceiling is refused before the execution record is written. Attribution before generation is a strong property; it is not the same thing as a complete record of everything the platform declined to do, and we are not going to let the first imply the second.
What we would rather you did with this. Ask us to show you the test failing. Add a call without a workspace to a branch, watch the build go red, and then decide what the rest of this page is worth. That is a five-minute exercise and it is more informative than any assurance we could write here.
The plan changes your allowance. It does not change your controls.
Three of the four rows in this table are the same on every plan, and that is the point of showing it. Injection screening, redaction, the workspace on every call and the money-and-stock lock are identical whether you pay nothing or you pay for Enterprise. Our plan catalogue differentiates exactly one AI dimension, and it is the last row.
We think that is the only defensible arrangement. A security control sold as an upgrade is a control we would have to describe as optional, and none of these are. What you buy with a larger plan is more room to work — not a safer product.
See full pricing| Plan | Injection blocking | PII redaction | Money and stock locked until switched on | AI credits a month |
|---|---|---|---|---|
| Free $0 | Included | Included | Included | 50 |
| Starter $19 | Included | Included | Included | 1,000 |
| Pro $59 | Included | Included | Included | 5,000 |
| Business $129 | Included | Included | Included | 15,000 |
Frequently asked
Can an administrator turn the AI guardrails off?
Two of them, no — there is no setting anywhere, on any plan, in any workspace. Every prompt is scanned for injection patterns and scrubbed of personal data before it reaches the model, and before it reaches the copy we keep. A separate layer on top of those two is configurable: restricting which tools an agent may call, putting a ceiling on the value of an action, and requiring a confidence score before something proceeds. That layer is a deployment-level setting rather than a plan feature, so if you are relying on a specific part of it, ask us to confirm it is switched on for your workspace rather than assuming it from this page.
What happens when I run out of AI credits?
You get a refusal — an HTTP 402 with an upgrade message — rather than a larger invoice, and the important detail is that the refusal happens before the call, not part-way through it. A call has to fit in what is left of the month: if you have four credits and the action costs five, it does not start and you are not charged four. Two honest caveats. Whether reaching the cap hard-blocks is a deployment switch, so confirm it with us before you treat the number as a wall. And no plan in our catalogue carries a metered price today, which is what actually makes credit use un-surchargeable — it is a pricing fact, not a lock in the code.
Which AI provider does Oneop use, and is my data used to train models?
Google Gemini, exclusively. There is no multi-model routing, no model picker, and no GPT or Claude path — a request naming another provider is still served by Gemini, and we deliberately do not publish the specific model versions on this page because they are configuration and they change. Prompts go to Google’s Generative Language API to serve your call and nowhere else. Oneop has no training pipeline of its own; there is none in the codebase to describe. How the model provider handles what it receives is governed by Google’s terms for that API rather than by us, and we will not characterise a third party’s practices on our own marketing page — the current data-processing terms are at /trust/dpa.
Can AI touch my accounting or my stock?
Not until somebody deliberately switches those actions on, and they ship off. While they are off they are refused at the single point where every action is dispatched — which means the refusal holds in the most permissive autonomy mode, and it holds even after a human has approved the action, because the check sits underneath the approval rather than beside it. Switched on, money and stock actions create draft records through the same services your staff use and under the same invariants: posting a bill to the ledger still needs its own separate human approval, and stock still cannot go below what is physically available.
Do the controls change depending on which plan I am on?
No, and this is the one place we would rather show the table than describe it. Our plan catalogue differentiates exactly one AI dimension: how many credits a month you get. Injection screening, redaction, the workspace attribution on every call, the money-and-stock lock and the evidence trail are identical on the free plan and on Enterprise. There is no security tier here, because a governance control that only paying customers get is a governance control we would have to argue was optional — and it is not.
Is every AI action guaranteed to happen exactly once?
No, and we would rather say so than let you find out. Where a call is retried with the same idempotency key it is deduplicated and charged once, and where an approved action is dispatched it happens inside a single transaction with the approval, so a failure rolls the approval back rather than leaving it in limbo. But a longer-running process that is interrupted and resumed can re-enter the step it stopped in, and not every step is safely repeatable. If you are automating something whose second occurrence would be a problem — a payment, a shipment, an outbound message to a customer — put the approval step in front of it rather than relying on us to promise exactly-once, because we do not.
What is actually written down, and when?
Three different times, and they are worth telling apart. Before the model runs, the credit reservation is written in the same transaction that charges it — so the spend record cannot exist without the workspace on it. After the call, an execution record is written on the success path and the failure path alike, carrying which model actually served it, how many tokens it used, how long it took and the error text if there was one; an audit row goes alongside it. And the honest third: a refusal is not written to that history. A prompt blocked for injection, or a call stopped at your ceiling, is refused before the record is created, so you will see it in your error handling rather than in your AI history. We are working on that, and we would rather tell you than let you assume an empty history means nothing was attempted.
Judge this the way you would judge a supplier.
Your own AI history after a day of use reads back: what was charged, what model served it, what failed. Or book a walkthrough and we will show you a refused money action, a run that hit its ceiling, and the build test behind the guarantee on this page — in that order.
Free forever · 2 seats · No credit card