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.

John Morton
November 18, 2026
Best Practices
Command Your Own AI Blog Thumbnail

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:Β 

Chart showing the three control data planes for AI

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.

John Morton
John is a field-facing cybersecurity executive with 15+ years leading high-performing technical sales teams. He has deep expertise designing and scaling cloud-native security solutions across AWS, Azure, and GCP, specializing in identity, access governance, Zero Trust architectures, and entitlement management. As a veteran leader, he blends technical depth, pre-sales excellence, and strategic vision to accelerate growth, customer trust, and market leadership.

See Nucleus in Action

Discover how unified, risk-based automation can transform your vulnerability management.