Command Your Own AI: The Missing Control Layer Between AI and Security Data
Choosing your AI is only the beginning. The bigger question is how much control that AI should have over your security data.
In my last article, Thereβs Something Missing in the Discussion About AI in Vulnerability Management, I argued that vulnerability management vendors probably shouldnβt be making long-term AI decisions for their customers.Β
The idea was relatively simple:
The platform determines what is known. AI helps determine what it means.
Vulnerability and exposure management platforms operate on deterministic facts: assets, vulnerabilities, ownership, controls, exceptions, remediation status, and risk. AI operates probabilistically against the context we give it.
That distinction matters, and it led me to the idea of Commanding Your Own AI.Β
Naturally, I look at this from the perspective of our own product and customers. Nucleus provides the exposure intelligence and our customers choose the AI that aligns with their enterprise strategy. Their security data remains the source of truth, while AI becomes another interface for interacting with it.Β
But Iβve been thinking there is another layer to this conversation. If customers bring their own AI, how exactly should that AI interact with security data?Β
The obvious answer is to connect the AI to the data and let it figure things out.
Iβm increasingly convinced thatβs the wrong architecture.
Donβt Give AI the Keys to Your Security Data
AI shouldnβt need unrestricted access to your vulnerability data to be useful. Add to that the fact thatΒ a probabilistic model shouldnβt be responsible for inventing the rules governing how authoritative security data gets queried.Β
There should be a control layer between the two.
Think of the architecture this way:
Enterprise AIΒ
Β Β Β β intentΒ
Governed interfaceΒ
Β Β Β ββ Allowed operationsΒ
Β Β Β ββ Valid fieldsΒ
Β Β Β ββ User permissionsΒ
Β Β Β ββ Data scopeΒ
Β Β Β ββ Result limitsΒ
Β Β Β ββ Error and recovery rulesΒ
Β Β Β βΒ
Exposure management platformΒ
Β Β Β β authoritative security contextΒ
Bounded resultΒ
Β Β Β βΒ
Enterprise AIΒ
Β Β Β ββ ReasonΒ
Β Β Β ββ SummarizeΒ
Β Β Β ββ CorrelateΒ
Β Β Β ββ PresentΒ
Β Β Β βΒ
UserΒ
Thatβs a fundamentally different approach from exposing a large security dataset and asking the AI to figure out what matters. To summarize the approach:
- The AI expresses intent.
- The control layer determines what the AI is allowed to ask.
- The security platform determines what is true.
- The AI then helps determine what those facts mean.
MCP Makes That Separation Practical
This is one reason I think Model Context Protocol (MCP) is much more interesting than simply being another AI integration standard.
MCP can create a defined boundary between an enterpriseβs chosen AI and the systems containing authoritative business or security data.
Nucleus MCP Server already takes this approach. AI clients authenticate as the Nucleus user, and MCP interactions remain governed by the same RBAC and Asset Group Access Control policies defined inside Nucleus. The MCP Server also exposes structured capabilities for projects, assets, findings, vulnerability metrics, and Nucleus Query Language (NQL) rather than granting some new blanket level of access to the platform.Β
Connecting AI to your security platform shouldnβt mean handing the AI your entire security data plane.Β
It means giving AI a governed interface to the security context required to complete a specific task.
Think in Projections, Not Data Dumps
Suppose someone asks their enterprise AI:
βShow me the ten highest-risk Critical findings affecting externally exposed assets.βΒ
The AI doesnβt need to blow through tokens blindly querying every asset and finding in your vulnerability management program.
It needs a bounded projection of authoritative exposure intelligence:
Severity = CriticalΒ
ExposureΒ Β Β Β Β = ExternalΒ
SortΒ Β Β Β Β Β Β Β Β = Risk score descendingΒ
Maximum rowsΒ = 10Β
OperationΒ Β Β Β = Read onlyΒ
Nucleus determines which findings actually meet those conditions.
The AI gets the context required for that task and can then explain it, summarize it, correlate it with another authorized enterprise source, or turn it into an executive report.
This gives us three distinct responsibilities.
The AI Owns Reasoning
What is the user trying to accomplish? How should the answer be explained? What broader context might be relevant?
The Control Layer Owns Policy
Which operations are permitted? Which fields and values are valid? What data can this user access? How much information should this request return?
The Exposure Management Platform Owns Truth
Which assets exist? Which vulnerabilities affect them? Which are externally exposed? What is their current status? What risk and business context surround them?
Each technology gets to do what it is actually good at.
What Happens When AI Gets It Wrong?
This may be the most important part. Generative AI will make mistakes. Pretending otherwise isnβt an architecture.Β
Imagine the AI attempts to query a security property with a value that doesnβt exist.
The wrong approach is:
AI β invalid request β error β AI guesses what the system probably meantΒ
A governed approach can look more like:
AI β invalid request β deterministic system β rejected β valid values or constraints supplied β AI reasons about the correction β revised requestΒ
The distinction is subtle but critical.
The AI is allowed to reason about how to recover. It isnβt allowed to decide whatβs true.Β
The deterministic system establishes that. This is what I mean when I talk about putting probabilistic reasoning on top of deterministic security intelligence.
The goal isnβt to remove AIβs flexibility. Itβs to put that flexibility in the correct layer, with safeguards to ensure output accuracy.
Separate the AI Plane from the Security Data Plane
I think this will become an increasingly important design principle as AI moves deeper into enterprise security.
Organizations are already separating identity, authorization, policy, and data access from applications. AI shouldnβt somehow become exempt from those principles.
The architecture should increasingly look like this:Β
That separation makes the AI more replaceable without making the underlying security program more replaceable.
And thatβs exactly what enterprises should want.
Commanding Your Own AI Should Mean More Than Model Choice
When I originally wrote about this idea, a lot of my thinking focused on choice.
Some companies will standardize on Microsoft Copilot. Others may choose OpenAI, Anthropic Claude, Google Gemini, sovereign AI infrastructure, or models that havenβt been created yet.
Why should your vulnerability management vendor dictate that decision?
I still believe that.
But Commanding Your Own AI needs to mean more than being able to swap Model A for Model B.
I think it should encompass three things.
1. Choose Your AI
Your exposure management platform shouldnβt dictate your enterprise AI strategy. Model leaders will change. Enterprise requirements will change. Governance requirements will change. Your exposure management program shouldnβt have to change with them.
2. Control Your AI
Your AI shouldnβt receive unrestricted access to security data merely because someone connected it to an API. Give it defined tools, governed identities, bounded queries, controlled projections, and deterministic validation. The AI gets freedom to reason without getting freedom to redefine the rules of the system.
3. Change Your AI
The control and data layers should survive changes in the intelligence layer.
Today: Microsoft Copilot β MCP β NucleusΒ
Tomorrow: Enterprise Model X β MCP β NucleusΒ
The enterprise shouldnβt need to rebuild its vulnerability management foundation because its preferred AI changed.
That is what Commanding Your Own AI should ultimately mean.
AI Access Shouldnβt Become Another Premium Data Tier
There is another angle to this conversation that I think customers should pay attention to.
If youβre already paying for a vulnerability or exposure management platform, should connecting your chosen AI to the context you already own become another premium AI tollbooth?
Nucleus takes a relatively straightforward position here: our dedicated MCP capability is included with the product.
It is tempting to group all MCP offerings together, but implementations and commercial models can be very different.
For example, Tenable Hexa AI MCP Server lets customers bring an MCP-compatible AI client, but its documentation states that access requires either a Tenable One Foundation or Tenable One Advanced license.
Rapid7, by comparison, has introduced a free, open-source MCP server and Agent Skill tied to Bulk Export. Its documented architecture creates a local offline replica of Rapid7 data which can then be interrogated by an LLM.
All of these approaches demonstrate how quickly MCP is becoming relevant in security.
But they arenβt architecturally or commercially identical.
For me, the important Nucleus distinction isnβt simply βfree MCP.β
Included access. Customer-selected AI. Governed live context. Existing security controls. No mandatory vendor-selected model.Β
Nucleus MCP Server honors the userβs existing RBAC and AGAC permissions, including when NQL is used to interact with Nucleus data.
That allows the AI layer to change while the security governance and exposure-intelligence layers remain authoritative.
Your Security Data Should Outlive Your AI Strategy
This may ultimately be the larger point.
AI is moving incredibly fast. The best model today may not be the best model eighteen months from now.
The AI provider your enterprise standardizes on today may not satisfy tomorrowβs privacy, sovereignty, cost, performance, or regulatory requirements, but:
- Your vulnerability data still needs to be accurate.
- Your asset relationships still need to be meaningful.
- Your ownership and remediation data still need to be trustworthy.
- Your exposure intelligence still needs to be defensible.
- Your access-control model still needs to work.
Those things shouldnβt depend on which logo appears on the AI interface. Thatβs why I think the architecture matters more than the model.
Control the Boundary, Not the Intelligence
There is a natural temptation in AI security conversations to focus on controlling the model itself.
Which model? Which version? Where is it hosted? Which provider?
Those questions matter.
But perhaps an equally important question is:
What boundary exists between that probabilistic system and the deterministic systems your organization depends on?Β
Thatβs where I think exposure management platforms can provide something far more durable than another embedded chatbot.
Provide authoritative security context, preserve authorization, and control how the data can be accessed. Expose that context through standardized interfaces and then let customers decide which intelligence they want to put on top of it.Β
Thatβs the separation Iβm increasingly convinced matters.
- Nucleus owns the exposure truth.Β
- The security program owns the control plane.Β
- The customer chooses the intelligence layer.Β
Commanding Your Own AI shouldnβt mean handing AI the keys to your security data.Β It should mean giving the AI you choose a governed interface to the truth.
See Nucleus in Action
Discover how unified, risk-based automation can transform your vulnerability management.