Putting AI in Your SOC Without Sending Your Data to Someone Else’s AI

Every security vendor now has an AI story. Most of them work the same way: your alerts get shipped to the vendor’s cloud, a model the vendor runs looks at them, and a summary comes back. It’s useful. It’s also one more place your security data lives that you don’t control.

We’ve spent the last few posts explaining why nuvioIT deploys Sentinel, Purview, and the Defender stack inside each client’s own tenant instead of a platform we own. This post is about the next layer: how we’re building agentic AI on top of that stack, and how we did it without breaking the rule that your data stays with you.

The problem we’re actually solving

A properly tuned Defender and Sentinel deployment still generates a lot of incidents. Most of them are low severity and repetitive. A sign-in from a new location that turns out to be a user on vacation. A DLP match on a document that’s already labeled correctly. An endpoint alert on a known admin tool. Somebody has to open each one, pull the context, decide it’s benign, and close it with a note.

In a traditional SOC that’s Tier 0 and Tier 1 work. It’s expensive, it burns out analysts, and it’s where mistakes happen because it’s boring. The high-value work, the real investigations and the containment decisions, sits behind that queue.

That triage layer is exactly what a language model is good at when it has the right context and tight guardrails. So that’s what we built.

What the agents do

Inside each client’s Sentinel workspace, an agent picks up new incidents as they’re created. For each one it:

  1. Pulls the full context from the client’s own tenant: the Defender XDR incident graph, the affected user’s sign-in history, device health from Intune, the Purview label and DLP details if data is involved, and any related incidents from the last 30 days.
  2. Reasons through it against our detection playbooks, the client’s documented business context (who travels, what admin tools are approved, which external partners are expected), and the MITRE technique the rule maps to.
  3. Reaches a verdict with a confidence score and a written rationale.
  4. Acts within the limits we’ve set for that client. Right now that means two things. Benign incidents above a confidence threshold get closed with a full rationale written back to the incident. High-confidence true positives with an approved containment action, like isolating a device or revoking a session, get that action taken and a ticket opened for a human to review.

Everything else, and everything the agent isn’t sure about, goes to our analysts with the context already assembled. The analyst opens a ticket that already has the timeline, the evidence, and a recommended next step instead of a raw alert.

The result is that our human analysts start at Tier 2. The queue in front of them is smaller and every item in it is pre-worked.

Where the AI runs, and why that matters

This is the part that took the most engineering and the part we care most about.

The agents run on Azure OpenAI through Azure AI Foundry, deployed inside the client’s own Azure subscription. For DIB clients, that’s Azure Government, alongside their GCC High enclave. The model endpoint, the orchestration, the prompts, the logs of what the agent looked at and decided: all of it lives in the client’s boundary.

What that means in practice:

Your security data never leaves your tenant to be analyzed. The agent queries your Sentinel workspace and your Defender console from inside your subscription. Nothing is exported to a nuvioIT-owned AI service or a third-party model API.

Azure OpenAI doesn’t train on your data. Prompts and completions in Azure OpenAI are not used to train Microsoft’s models and aren’t shared with other customers. In Azure Government, the service sits inside the FedRAMP High boundary. That’s a very different answer than “we send it to a public model API and trust the terms of service.”

It fits your CMMC scope. The AI component is another Azure service in an enclave you already own and have already scoped. It doesn’t add an external system to your SSP, and your assessor can see exactly what it does because the reasoning is written back into your own incident records.

You can read every decision. Each incident the agent touches gets the rationale, the evidence it looked at, and the confidence score written into the incident in your Sentinel. If the agent closed something, you can see why. If you disagree, the incident is still there.

You keep it if you leave. The deployment lives in your subscription. Revoke our access and the agent, its configuration, and every decision it ever logged are still yours.

How we built it

We built the agentic layer as part of Aegis Unified, the platform we use to deploy and operate client security stacks.

One codebase for Commercial and Government. The agent deployment is defined in Bicep and deploys the same way into Azure Commercial or Azure Government. The differences between the two environments are handled as configuration, not as separate products. A commercial client and a GCC High client get the same agent logic, the same playbooks, and the same guardrails.

Deployed per client, not shared. Same principle as everything else we do. There is no central nuvioIT AI service looking at every client’s incidents. Each client gets their own deployment, with their own model endpoint, their own business context, and their own thresholds.

Guardrails first. The agent has a defined set of actions it’s allowed to take, and that set is agreed with the client before deployment. Closing an incident and isolating a device are on the list because they’re reversible and auditable. Deleting evidence, changing policies, or modifying user accounts beyond a session revoke are not. Every action is logged to the incident and to the audit log in the client’s tenant.

Confidence thresholds we tune. We started conservative. Auto-close only fires above a high confidence bar, and containment only fires on a narrow set of detections where a false positive costs less than a delay. We review the agent’s decisions against analyst decisions and adjust per client.

Ticketing that already exists. Our Sentinel integration already opens and updates tickets in our PSA. The agent uses the same path, so anything it escalates shows up for our analysts with the full context and anything it auto-closes is recorded the same way a human close would be.

What it doesn’t do

We think it’s worth being clear about the limits, because the AI marketing in this industry mostly isn’t.

It doesn’t replace investigation. Anything novel, anything with real blast radius, and anything the agent isn’t confident about goes to a person.

It doesn’t have free rein. The action set is narrow and fixed. The agent can’t decide to do something we didn’t authorize.

It doesn’t run anywhere but your tenant. There’s no nuvioIT cloud in the loop.

It isn’t magic. It’s a model with good context, good playbooks, and tight controls doing the repetitive part of SOC work so our analysts can do the rest.

What this gets you

  • Faster time to close on the incidents that make up most of the queue
  • Faster containment on the ones that matter, with a human review behind every automated action
  • Analysts who start every ticket with the context already assembled
  • Every decision documented in your own Sentinel, readable by you and your assessor
  • All of it inside your Azure subscription and your compliance boundary

The bottom line

We didn’t build AI into our clients’ security stacks by shipping their data to a model somewhere. We built it inside each client’s tenant, on Azure OpenAI and Azure AI Foundry, in Azure Government for the clients who need it, with every decision written back where the client can read it.

Your stack. Your data. Your AI. We run it.

If you want to see what this looks like against your own incident queue, reach out.

Let's talk

Ready for your new vision?

Book a free security assessment and threat briefing. We will map where you stand, what matters most, and which plan fits.