Introducing the NexusOne AI & Data Control Plane
One boundary over every model, engine, user, and agent. Route each AI request to the right place, govern it at the edge, and see exactly what it costs, all from a single control plane.
Most enterprises spent the last year standing up AI as fast as they could. Copilots for engineers, assistants for analysts, and now agents that act on their own. Almost none of those same enterprises can answer three basic questions today about what they built: what exactly is AI costing us, what data is AI touching, and can we prove AI stayed inside the rules.
There is a reason none of those questions have a clean and easy answer: the data, the models, and the agents are each governed in different pieces and systems, if they are governed at all. Spend lives in a cloud bill. Data rules live in your warehouse. Agent behavior might live nowhere for local models. No single source of truth — so no one can say what the whole system of AI, agents, and applications are doing.
Today we are launching an enterprise-grade solution to finally put all three in one place. The NexusOne AI & Data Control Plane sits over every AI model, every inference engine, every user, and every agent in your organization — including the data underneath them, all governed by the same identity rules. We route each request to the right place, enforce governance at the boundary, and record everything so you can see it and prove it. A control plane, in plain terms, is the critical missing layer that decides where queries go and what AI should be allowed to do, separate from the systems doing the work. This missing piece for AI will enable scalable enterprise AI and data under a single control plane.
Every data leader is facing big questions about AI in 2026
AI cost has become unpredictable, and the meter runs in the wrong direction. Every request to a frontier model burns tokens, the units of text an AI model reads and writes, and you pay for each one. Teams spin up assistants without budgets, agents call models in loops, and the bill arrives a month later with no way to attribute it. The incentives of your cloud and model vendors point the same way: they earn more when you burn more.
There is no intelligence in where requests go. Most AI stacks send everything to one large model because that is the path of least resistance. A request to reformat a date and a request to reason over a contract get the same expensive treatment. Meanwhile the field is moving toward smaller, specialized models, often called SLMs, that beat the giant generalist on a narrow task at a fraction of the cost. Without a routing layer, none of that saving is reachable intelligently at scale.
Agents now act, and nobody set the boundaries. A chatbot answers questions. An agent actually runs queries, calls tools, and reaches for data on its own. We think of the current wave of agents as toddlers that were just handed knives: capable, fast, and with no sense of where the edges are. The boundary that keeps an agent from reading data it should not, or running an action it should not, has to live somewhere. In most stacks it lives nowhere today.
Cost, safety, and policy each get handled — if at all — somewhere apart from the data the request actually reaches, so nothing ever has the whole picture. The solution is one control plane over all of it: every model, every engine, every agent, and the data underneath, governed as one system.
Meet the NexusOne AI & data control plane
The NexusOne AI & Data Control Plane routes, secures, governs, and monitors every single AI request from every user — and every agent — in a single place. One boundary, one identity, one set of rules, applied the same way to a person, an application, and an agent, across every model and every data system underneath. You set a rule once centrally instead of re-implementing it in each app and each model. Everything below — the routing, the security, the cost control, the audit trail — follows out of that design decision to govern it all in one place.
It routes on intent, not guesswork. When a request arrives, the control plane first matches on who the user is, their role and permissions, then reads the prompt to understand what they are trying to do. A coding request, a data request, and a general question each follow a different path. The control plane marries deterministic and non-deterministic queries in one place, routing each to the right kind of compute. A deterministic request, where the same input should always give the same answer, goes straight to a query engine. A predictive question goes to one of your existing machine learning models or data pipelines. Only generative or reasoning work that needs it goes to a language model, and then the smallest one that does the job sufficiently. Most requests never need a frontier model, and many never need an AI model at all. The user sees none of this; they ask, and the right thing happens behind the scenes.
Requests enter on the left, pass through signal checks, match a routing decision in priority order, run that route’s plugin chain, and land on an endpoint. A user query on the left is scored by signals (keyword, authorization, jailbreak, PII), matched to a routing decision by priority, passed through that route’s plugin chain, and sent to the cheapest endpoint that can do the job, from a local ministral-3:8b to claude-opus-4-8.
It governs at the boundary, by identity. The same request is checked before it reaches a model. If a prompt tries to override its instructions, a jailbreak check stops it. If it tries to pull out personal data, a PII check stops it. We ran a request that asked the system to write a query, quietly run it, and return the user records behind it. The control plane refused, and the request never even reached a model or the data. Paste in an API key and tell an agent to call something it should not, and you get the same answer. Every block is logged with its reason, and every decision follows the user’s identity and permissions centrally, so you set the rule once rather than in every application. This is made possible because the same NexusOne plane also governs the data — the boundary that already protects your tables is the boundary that now protects every model and agent reaching for them.
A request that tried to pull user records is stopped at the boundary. The safety gate detected personal data and a jailbreak pattern, refused the request before any model or data was touched, and logged the block with its reasoning.
It records everything, so you can see it and prove it. Because every request flows through one place, the control plane captures the full picture: estimated spend and how much of it went to expensive cloud tokens versus your own models, which models are used and how fast each responds, who is consuming the most, and every security event over time with the reason it was blocked. Underneath the charts sits the full record of each request, what was asked, what came back, whether it was cached, whether guardrails or retrieval or hallucination checks were applied. One request path means one audit record, one cost view, one security log — the single source of truth your CFO, your CISO, and your regulator can each query without anyone stitching four tools together. You build whatever dashboard your team needs on top of it.
The governance and FinOps dashboard. The KPI row totals every request in the period, with estimated spend split between cloud tokens and local execution, and the charts underneath break requests down by routing decision, local versus cloud, and blocked versus allowed (demo workspace data).
Interactive demo: Try routing an AI query yourself
Try our interactive demo to see how different kinds of AI user queries — including malicious attacks and prompt injections — route through the NexusOne AI & data control plane and the logical explanation.
Control and predict your AI token costs
The control plane answers any frequent or repeated questions from a semantic cache, so an identical request inside a short window returns instantly and burns zero tokens. It enforces per-role token budgets, so a given role has a ceiling it cannot exceed and a maximum spend per request. It sets priorities across endpoints and routes to the lowest-cost option that can do the job, including your own hosted models. And it sends each request to the right kind of compute, deterministic work to a query engine, predictive work to an existing model or pipeline, narrow tasks to small specialized models, so a frontier model is used only for the genuinely generative work that needs one. Cost savings come from architecture, not from asking anyone to use AI less — and because cost, security, and governance all run on the same request in the same plane, controlling spend never means giving up control over what AI touched or whether it stayed in policy.
Building on the NexusOne approach to data for AI and agents
This product is the next layer of the same approach we have taken to the whole data estate.
We built composable infrastructure that runs the same stack across cloud and on-prem hardware. We built composable data, and the part that mattered most was bringing fine-grained access control across all of it: a control plane that sits over every data system whether we run that system or not. Putting a control plane over AI follows naturally, applied to models and agents instead of tables. Governed data is the precondition for governed AI — you cannot prove what an agent did with data you do not already govern properly. That is why the governance here is not bolted on. The boundary that protects your data already exists, and the AI control plane extends it to every model and agent, under one identity and one policy model.
Why govern all of it in one plane? Because your data and your AI are not separate systems. The same request that calls a model also reaches your data and acts through an agent, so governing them apart guarantees that nothing ever sees the whole. When all your data and all your AI live under one control plane, the rule you set once applies to every human, app, and agent, across every model and every data system; every request is governed against the data it actually touches; and cost, safety, and audit are read off one record. (A side benefit: the router, the guardrails, the observability, and the data governance you would otherwise run as separate perimeters become features of the one plane rather than four systems to wire together — but the point is the coverage and the coherence, not the tool count.) As the program scales from one pilot to fifty agents acting across the estate, that is the difference between a demo that works and an AI program finance, security, and your regulator can all approve happily.
Why can’t your current cloud provider or model vendor just do this for you? They can, for their own models, inside their own platform. What none of them will do is route you to a cheaper competitor, manage your on-prem estate alongside their cloud, or give you the controls to spend less with them. Their business model is based on consumption and lock-in. Ours is the opposite. We sit across all of them, are not paid by the token, and we have no reason to keep you on any single provider. NexusOne does not compete with your model vendors or your cloud; it is the connective layer on top of them — and the only one that governs your data and your AI as one system.
Powering the next generation of AI data innovators
Early design-partner deployments are underway, including at a top-five US bank. There is hardening and deeper integration still ahead, but early signal from users and customers gives us confidence in the approach, and we're excited to build it alongside you and our other early AI innovators.
As our CEO Anu Jain put it to the team: “The hard problem was never managing the data or managing the AI on its own. It was making them work together, as one system, and giving you full control over your entire AI estate regardless of where it lives.”
See it in your own stack
If you are responsible for what AI costs, what it touches, or what your agents are allowed to do, the fastest way to judge this product is to point it at your own environment. Bring your model mix, your governance rules, and the hardest question on your desk about cost or agent risk, and we’ll be happy to show you what the control plane does with each request.
Book an expert consultation: www.nx1.io/get-demo