Reasoner
Ask, and Oria reasons over governed data and institutional memory. Dashboards, maps, simulators, relationship graphs, timelines and work boards come out of the conversation, not out of a ticket.
Meet Oria
The super agent that knows how your organization works.
It reads the ERP, CRM and data platforms you already run through a governed reflection of them, and every account arrives with Cerebro, the institutional memory your people already wrote down. Your team asks, analyses, builds and acts from the first session, with budgets and an audit trail.
Oria can
- reason over your governed data.
- draw on the lessons your team already learned.
- replace the spreadsheet everyone emails around.
- build the dashboard you were going to export for.
- ship the app your team asked for.
- act on it, with an approval where the money moves.
- write down how the business works, with a person approving it.
- remember why you decided it.
Start today
30 minutes to size it. Your team works the same week.
WHAT IS AT STAKE
Your advantage should not live inside someone else’s product.
The assistants your people already use know an enormous amount about the world and nothing in particular about your company. Every vendor is closing that gap the same way, by holding your context for you: your documents, your decisions, the patterns in how you work, kept as a feature inside their assistant.
The gap is real and it does need closing. The question is which side of the line the thing that makes you different ends up on.
- You cannot audit what it absorbed, or reconstruct why it answered the way it did a year ago
- You cannot take it with you. It leaves when the contract does
- You cannot decide which model sees which part of it, because that is the vendor’s routing and not your policy
- You cannot see what any of it cost, because a seat with a usage limit has no unit price
- Its shape follows a roadmap you do not write
ARPIA keeps that layer on your side of the line. The ontology is your own model of how the business works, and Cerebro is the record of how it decides. Both live governed inside your tenant, with lineage and attribution.
Oria reasons over them, and every call out to a model provider is scoped to the domains you allowed, enforced on the server, budgeted before it runs, and logged with which model saw what context under which rules. You choose the models and you can bring your own provider keys.
You also see the price and not only the ceiling. The models your people reason with carry a published rate per million tokens, input and output separately, and each call is costed against that rate, cached tokens included, down to a single agentic run. You can see which model spent what, and a budget stops the spend before it happens instead of explaining it afterwards.
So you govern the access instead of granting it once, and the corpus stays readable from the tools your people already use through MCP.
An organization’s real advantage is how it decides: the rules it learned the hard way, the reasons behind the calls that worked. Written down and governed, that becomes an asset with your name on it. Left inside somebody else’s assistant, it becomes part of their product.
WHAT YOUR PEOPLE GET
Four surfaces, one governed session.
Oria is not a chat window bolted onto your data. It reasons, builds, authors and executes, and every one of those runs inside the same governed session, on the governed data and the permissions the business already defined. Each one has a demo, no slideware.
Coder
Generation constrained by your own model of the business and your security policies, with a review gate before anything ships. The standards are the guardrails, not a code review afterwards.
Workbench
Author the ontology itself: nodes, relations and the tables behind them, with permission gates on propose, apply and sample. This is where the DNA of the business gets written down.
Oria Machine
A governed execution environment. Code runs in its own pod with the same scope and permissions, human approval where it matters, and its own persistent storage.
ONE SCREEN
This is where your people work.
The experts on the left, the work in the middle, and on the right what the session is allowed to know, use and produce. Nobody switches tools, and nothing leaves the governed session to get done.
Experts
A named expert holds its own nodes and its own tools, so a session starts already scoped to a job instead of starting empty. The lead analyst and the person preparing a proposal are not looking at the same data or reaching the same systems.
Cerebro
The institutional memory, on in the session and counted: what the organization has decided, the rules it works by, and why. It arrives with the account, so the first session already knows something.
Ontology nodes
The business objects this session can reason over, named as the business names them, and each one governed. Adding or removing one changes what the answers can be built from, in the open, not in a prompt.
Tools
What the session may reach beyond the data: search, documents, live applications. Each one is listed, configurable and removable, so the reach of the AI is a decision somebody made and can revoke.
Artifacts
What the session produced and kept: a live simulator, a costed proposal as a four page PDF, a board. They are versioned and they stay with the session, so the work is not a message somebody has to find again.
Files
What you brought in and what came out, side by side. A document dropped into the session is read under the same permissions as everything else, and what the session generates is listed beside it.
Agentic steps
Every answer carries the run behind it, folded away until you want it: the steps taken, the model that ran and what it cost in tokens. And where an action touches something that matters, it stops and waits for a person to approve it. Most assistants show you the answer. This one shows you the work.
THE DIFFERENCE
Every other assistant reads. This one writes.
Most companies already have an enterprise chat assistant. It answers well, and then the work starts: you take the answer somewhere else to analyse it, and somewhere else again to build anything with it. It can only reach what somebody already wrote down, and the decision taken in a meeting or the rule that surfaced while debugging is not in there, because nobody ever typed it. That is also the knowledge that walks out when a senior person resigns.
The enterprise AI chat you already pay for
- Answers and drafts, then you copy the result into another tool to do anything with it
- Reads what somebody already wrote down
- Memory is per user, opaque, with no attribution
- No governed view of the operational data, so no analysis you can act on
- Nothing it produces is attached to the entities the business runs on
Oria, on ARPIA
- Records what the organization decided, as a byproduct of the work
- Analyses governed data and returns dashboards, maps, simulators and boards
- Builds applications against your ontology, reviewed before they ship
- Every institutional claim carries the id of the memory behind it, and the corpus stays readable from outside through MCP
- Full lineage: which model, on what context, under which rules, approved by whom
What that looks like on an ordinary Tuesday:
The spreadsheet somebody maintains by hand is where most of the real operating knowledge of a company lives. Oria takes it, understands it next to your governed data, and gives back a working tool rather than a summary of it.
01
Drop the file in
Excel or CSV into the session. It lands in the object store, shows up as a file in the exploration, and the agent reads it alongside the nodes you already gave it.
02
Ask for the thing you actually need
Not a summary of the sheet. A dashboard, a map, a simulator, a work board, or a small application over that data, built in the session and pinned there.
03
Wire in the tools you use
Connect your own accounts through MCP with your own sign in. The agent uses them as tools in the same session, under the permissions your organization already set.
04
Leave it running
The work executes in its own governed environment with approval where it matters, keeps its own persistent storage, and can be promoted from your workspace to the organization's.
The point is the whole cycle in one governed place: ask, analyse, build, decide, act, and the record accumulates while you do it. The part that is hard to copy is not the memory, it is that the memory lives beside the ontology. When a memory says how churn is calculated, the node that calculates it is one step away, with its lineage and its governed actions. A memory layer on its own is a two quarter build for anyone. That is why this sits on a data platform and not on a search index.
It scales down as well as up. A team of twenty gets the same governed cycle as a company of three thousand, at the price of the seats they actually use.
ARPIA is certified under ISO 42001 and SOC 2 Type II, and Oria inherits that infrastructure. Your own compliance stays yours to run, but the governance layer is not something you have to build first.
WHAT COMPOUNDS
Cerebro comes with the account, from Basic.
Not an add-on to configure later. Every account is provisioned with its institutional memory ready and embedded in Oria, switched on in every session, for the Reasoner and for the Workbench.
- Answers lean on the decisions, rules and procedures the organization already recorded
- Immutable rules are injected whole into every turn and govern the answer, which is refused if it would break them
- The user decides which domains the AI may read in that session, and the limit is enforced on the server
- Three ways in: the agent when asked, one click, or automatic capture to a personal domain
- Writing to a shared domain always needs a human to confirm it
Six months in, you have not just been using AI. You have a written record of how your organization reasons.
And it is not held hostage. The same corpus is readable from the AI tools your people already use, through MCP. The pitch is not stay because your memory is here. It is work wherever you want, this is where it accumulates.
It starts empty and gets better with use, so we seed it during onboarding with the documents, tickets and wikis you already have. Oria begins knowing something, and from there the work keeps it alive.
WHERE IT LANDS FIRST
The teams that feel it in the first week.
Every one of these ends in something governed: a pipeline that ran, a board that is live, a decision with its lineage attached. Not a document somebody has to carry to the next tool.
Finance
Which accounts to chase, and the collection already moving.
Oria maps the exposure, diagnoses what changed, prescribes the action and activates it into the ERP, with human approval where the money moves.
Out: a governed pipeline that ran. Collections went from days to 13 minutes, trigger to ERP, in production at a financial services group.Operations
What the agents are doing right now, on one board.
Running objects, errors, what is waiting on a person. Operations stops asking whether a flow ran and starts seeing it.
Out: a live operations board. Metrics and object states update as the work happens.Commercial
A price or a forecast that arrives with its reasoning.
Competition, inventory and sales history combined into a recommendation you can interrogate, because the reasoning that produced it is attached to it.
Out: a recommendation with its lineage. Analysis that took weeks resolves in minutes.Risk and compliance
Every AI decision, reconstructable.
Which model ran, on what context, under which policy, approved by whom. Budgets are enforced before the spend, not discovered on the invoice.
Out: an audit trail you can hand over. Built for scoring and decisioning that has to answer to a regulator.Data
What breaks if this column changes.
Lineage that covers the tables and the reasoning objects on top of them: pipelines, nodes and the apps that read them, in one graph.
Out: lineage across data and reasoning. Most tools trace tables and stop there.Technology
What the business asked for, built inside your standards.
Generation constrained by the ontology and the security policies, with a review gate before anything ships, and code that runs in its own governed pod.
Out: reviewed work, not a prototype. The guardrails are the standards, not a code review afterwards.WHAT IT RUNS ON
Oria runs inside the platform, not on top of it.
An Oria seat is a seat on ARPIA. The same tenant, the same ontology, the same permissions and the same audit trail that govern everything else the platform runs. There is no integration project between Oria and the platform, because what your people do in a session is already running there.
So the capability underneath is not a later purchase. It is deployed with the account and opened by the seat: Basic reasons and builds inside the session, Pro shares what it builds with coworkers, Builder authors the ontology, configures governance and deploys what the whole company runs. When the work asks for more, you widen a seat instead of starting a procurement.
- Systems connected, extended or built new. Your ERP, CRM and warehouses read through a governed reflection instead of another copy.
- Your ontology, governed by design. What the business calls its entities, written down once and enforced everywhere.
- Any AI, frontier or sovereign. Model assigned by role and profile, your own keys if you prefer, with the published rate per million tokens behind each call.
- What it knows, with attribution. Institutional memory that carries its author, its source and its approval state.
- It touches only what policy allows. Permissions and budgets enforced on the server, before the call runs.
- It builds inside your standards. Generation constrained by the ontology, with a review gate before anything ships.
- It acts on the record. Governed actions back into the systems, with human approval where the money moves.
- Every decision can be explained. Which model ran, on what context, under which rules, approved by whom.
This is the same platform our forward deployed teams build on, and the same one your Builder seats work in. See the platform, step by step →
PLANS
Start with seats. Grow when the work asks for it.
Three levels, billed per seat per day, so a seat added mid month costs what it used. The AI itself is paid separately and you set the ceiling.
Oria Basic
$10/user/month
For putting governed AI in everyone's hands.
- Multi-model AI with governance
- Model assigned by role and profile
- Budget controls and shared AI Wallet
- Cerebro included and preconfigured, on in every session
- Builds artifacts and live apps inside the session
- Internet search
- Security and audit trail
- Runs any app already built on ARPIA
Builds for itself, inside the session.
Oria Pro
$50/user/month
For the people whose tools other people end up needing.
- Everything in Basic
- A more capable Reasoner, running on Oria Machine
- Apps built on your own ontology access, shareable with coworkers
- Persistent repository storage for that work
Shares what it builds. Does not change the platform.
ARPIA Builder
$100/user/month
For whoever owns the ontology and the governance.
- Everything in Pro
- Data management
- Ontology authoring and governance
- AI governance configuration
- Workshop project creation
- Deploys and manages what the whole company runs
Institutional building, not just personal.
Why the seat is cheap
Because you are not buying intelligence by the seat. AI consumption runs on a prepaid AI Wallet, a shared pool you size and control, billed on what was actually used. The models your people reason with carry a published rate per million tokens, input and output, and each call is costed against that rate, so the wallet is not a black box you keep topping up: you can see which model spent what. That is what keeps a governed seat at ten dollars instead of sixty.
Or bring your own models
Connect your own provider accounts or keys and the tokens stay on your bill. ARPIA charges a flat governance fee of $1 per million tokens, whatever the provider or model tier, for the budgeting, assignment, audit and policy that traffic passes through.
KEEPING CONTROL
Everyone gets AI. Nobody gets a surprise invoice.
This is the part nobody demos, and it is the part that decides whether AI survives its first conversation with finance. Four screens, in the order the questions actually arrive.
Who may use which model
A curated group of models is bound to a role, not left to each person's judgement: the agents get the fast and cheap ones, the managers get the reasoning ones, the builders get the coding ones. The first model in a group is the default, and a person picks from their group and no further. Nobody is blocked from working, and nobody is on the expensive model by accident.
What it may spend, before it spends it
A budget per model and period, with its token limit and the threshold that raises the alert, enforced on the server rather than asked of the user. The advice is in the product itself: start with alerts, and turn on the hard stop once you know what normal looks like. Until you decide otherwise, consumption is never blocked.
Where it actually went
Credits, calls and tokens for the period, then the same spend cut three ways: by product, by workarea and by model. That is the answer to the question that arrives right after the first invoice, which is never how much, it is who. And it is the same number the bill is built from, not a separate estimate.
What it will cost this month
Consumption so far, the projection to month end, the comparison with last month, and the wallet with how much of its ceiling is gone. Seats sit beside it, because they are the part that recurs. A finance team can read this screen without anyone translating it, which is the only version of cost transparency that counts.
WHERE IT GOES
The platform conversation, when you have earned it.
01
Seats
Your people work with governed AI. Spend is capped, every session is auditable.
02
Memory
Findings accumulate with attribution. The organization starts recognising its own knowledge.
03
Tools
Power users build apps and hand them to the people beside them. The useful ones spread on their own.
04
Ontology
What the business calls its entities gets written down and governed, by the people who know.
→
Platform
Now a use case is obvious, scoped and defensible, because it came out of the work instead of a slide. That is when our teams build with you.
Start today.
Tell us how many people, what they work on and what to connect. Thirty minutes is enough to size the deployment, and your team can be working the same week.
Size your deployment.
Who starts, what they work on, and what Oria should connect to. Thirty minutes on a call is enough to confirm it, and your team can be working the same week.