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
Most companies have one of them: a chat that does not know their data, or data with no AI that acts on it. Put together, and governed, they are what makes AI worth giving to everyone.
A governed reflection of your ERP, CRM, data platforms and documents, organized by your own ontology, plus Cerebro, the memory of what your organization already decided.
Governed. Your IP stays in your workarea, with zero data retention at the model providers.
How your data is governed →Anthropic, OpenAI, Gemini, open models or your own on your own GPUs, each job on the model that does it best.
Governed. Change the model and the work stays the same. No vendor lock-in.
How models are governed →The tools that put AI to work: dashboards and documents, apps your team opens, governed actions in your systems, Experts and Oria Machine.
Governed. Spend capped by area and by model, and every action recorded.
How the harness is governed →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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.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.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.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.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.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.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.
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 →
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.
For putting governed AI in everyone's hands.
For the people whose tools other people end up needing.
For whoever owns the ontology and the governance.
Oria Unlimited. Give Oria to your whole organization and stop counting seats. One platform commitment covers every user, and you scale on AI Wallet consumption instead: billed on the work that actually happened, not on how many people have a login.
Contact us →Past those allowances, storage and compute are billed at the normal published rate, the same way the AI Wallet bills tokens.
Every new workarea starts with $100 in the wallet, so the first sessions run before anybody loads a cent.
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 fifteen dollars instead of sixty.
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.
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.
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.
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.
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.
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.
Your people work with governed AI. Spend is capped, every session is auditable.
Findings accumulate with attribution. The organization starts recognising its own knowledge.
Power users build apps and hand them to the people beside them. The useful ones spread on their own.
What the business calls its entities gets written down and governed, by the people who know.
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.
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.
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.