For CISOs who run security across many sites and both IT and OT. Why the cloud SIEM model breaks now that AI agents are on both sides of an attack, and how a security operations center that runs on site keeps detection and response under your control.
For twenty years the Security Operations Center moved toward one model: send all the logs to a cloud SIEM and let a managed service watch them. That model assumed two things. Data could leave the site, and attacks were run by people. Neither is true any more. AI agents now act on both sides. Your teams use them to run operations, and attackers use them to automate attacks. Sites that mix IT and OT also cannot send large, sensitive data streams to a cloud that charges by the query.
This paper makes the case for an AI SOC that runs on site. It spots threats as data arrives and learns from your own environment. A knowledge graph links each alert to the people, systems and devices it touches, so you can see how far an attack could spread. Every person, service and AI agent gets its own identity and limits, whether the site is connected or air-gapped. Response keeps working when the network link drops, and your data stays on site.
The SOC has been climbing the same ladder for twenty years. In 2025 the ladder ended, and the ground changed.
Each rung added capability to a fundamentally reactive posture: the network operations center became a security operations center; rules gained machine-learning assists; threat intelligence enriched alerts; and SOAR automated the runbooks. Useful, incremental, human-paced. The 2025+ inflection is not another rung — it is a change in who acts. Agents are now on both sides of the wire. Adversaries automate reconnaissance, exploitation and lateral movement at machine speed; defenders deploy their own agents to triage, hunt and remediate. The volume, velocity and autonomy of action all step up at once.
The SOC's job is no longer to collect logs and correlate them later. It is to reason over relationships in the ingestion path, act autonomously within guardrails, and govern an estate where humans, services and agents all take actions that must be attributed.
The 2022–2025 reference design was a cloud-SIEM, managed-service model: ship everything to a regional SIEM, correlate centrally, bill per query. For a distributed IT/OT enterprise that model now works against you.
| Assumption of the cloud-SIEM model | Reality for distributed IT/OT in 2026+ |
|---|---|
| Telemetry can leave the site | OT, IoMT, video and process data are large, sensitive and often regulated — egress is a data-exfil and compliance risk |
| Cost scales gracefully | Cloud-SIEM fees recur on every event and query; agentic volume multiplies them without a ceiling |
| The link is always up | Plants, depots, substations and vehicles operate through outages; a cloud round-trip stalls incident response |
| Generic detections are enough | Vendor rules miss your environment; OT protocols and device behavior need locally-learned models |
| Detection is a search problem | At machine speed, delayed search and scheduled correlation are too late — detection must happen at ingest |
The OT estate compounds every one of these: long-lived devices, brittle protocols, safety constraints, no patch window, and air-gapped or intermittently-connected enclaves where a cloud dependency is simply unavailable. A modern SOC for this world has to run where the data is born.
The traditional SOC is twenty fragmented tools, each a console and a silo. The modern architecture consolidates them into four cognitive platforms feeding a single reasoning core that takes autonomous action.
Each legacy control does not disappear; it is absorbed into a platform and made cognitive. The point is consolidation of data flows, not just consoles:
| Control | What it was | What the reasoning core makes it |
|---|---|---|
| CSPM | Finds cloud misconfig & drift | Generates and tests infrastructure-as-code PRs to auto-close drift |
| SIEM | Centralized log search & retention | Correlates events as a graph, not sequential log scans |
| SOAR | Hard-coded mitigation playbooks | Playbooks reason over live topology instead of static scripts |
| EDR | Endpoint detect & remediate | Explains endpoint anomalies and auto-scopes remediation |
| MITRE ATT&CK | Manual tactic mapping | Auto-maps detections to adversary tactics in real time |
| MEC (edge) | Compute at the network edge | Compiles hyper-local models that detect anomalies at the edge |
| IDAM | Identity, RBAC, MFA | Adapts access policy to user, service and agent context in real time |
The core of a modern SOC is a model that reasons over events as they arrive and learns from your own environment. It runs entirely on site.
Detection happens in the ingestion path, on the GPU, while events are still moving. Each event is classified and enriched before it is stored, by a small model trained for the job instead of long chains of hand-written rules. That means threats are flagged in seconds, not found later by a scheduled search.
The model also learns your environment over time. The hard part is learning without drifting, so that a change never makes detection worse. The safe rule is simple: no change goes live until it has proven itself on cases it has never seen, and every change can be undone.
Detection gets better on your attacks, on site. Each change is tested before it goes live and can be rolled back. Your data never leaves the boundary.
Isolated alerts hide multi-stage attacks. A knowledge graph models the enterprise as a web of relationships, so a low-severity signal can be traced to its true blast radius.
Distributed IT/OT and agentic workloads share one root requirement: every actor needs a verifiable identity and a scoped policy — whether the site is connected or air-gapped. That is the job of a thin identity edge.
Rather than operate a heavy identity provider at every site, the architecture uses a thin authentication edge (an OAuth2/OIDC proxy with server-side sessions and edge RBAC) that delegates identity to the right issuer and injects a consistent identity context downstream. One pluggable setting selects the issuer; everything behind it stays identity-agnostic.
| Connected sites | Air-gapped / disconnected enclaves | |
|---|---|---|
| Issuer | The enterprise IdP — SSO, MFA and lifecycle stay where they already live; no local IdP to run | A self-contained on-prem OIDC issuer with its own user/group store — no external database, no cloud reach |
| Edge | Same thin proxy; same server-side sessions; same RBAC on a roles claim; downstream services receive identity via standard headers | |
| Switch | One pluggable issuer setting — applications and the SOC never change | |
A portable identity edge gives humans, services and agents one scoped identity model across the whole distributed estate — connected or air-gapped — and becomes the control point the SOC and the gateway both reason over.
Agents are a new class of actor. They act on behalf of users, call tools, read sensitive data and spawn sub-agents — at machine speed. Each action must carry an identity, a scoped credential, a policy and an audit trail.
This is where identity, the gateway and the SOC meet. The GPU EdgeGateway governs the agent's traffic: it routes each request to the right model on owned silicon, runs tools and code in policy-governed sandboxes (no unauthorized file, credential or network access), checks for sensitive-data leakage and prompt injection inline, and meters every call. The AI SOC governs the agent's behavior: it watches agent actions the way UEBA watches users, and uses the knowledge graph to bound what a compromised or misbehaving agent can reach.
| Agentic risk | Control |
|---|---|
| An agent acts with no attributable identity | Identity-driven core issues a scoped identity per agent and human-on-behalf-of relationship |
| An agent over-reaches its tools or data | EdgeGateway sandboxes tools/code and enforces policy-as-code on every call |
| A prompt injection or leak rides the request | Inline safety classifiers (PII, jailbreak, injection) on every turn at the gateway |
| A compromised agent moves laterally | AISOC traces blast radius on the graph and contains by relationship |
| Spend and action go unaudited | Every route metered and attributed; every action logged for review |
Unovie delivers this architecture as two offerings bound by the identity-driven core, all on Unovie's custom-built hardware accelerators.
A gateway for all AI agent traffic. It sends each request to the right model, local where possible. It runs agent tools in a locked-down space and checks every policy change before it goes live. It is also where each agent's identity and limits are enforced.
Security operations that run on your site. It flags threats as data arrives and uses a knowledge graph to show how far an attack could spread. It learns from your own environment, and it can act within limits you set: proposing fixes, isolating affected systems and keeping compliance evidence up to date. Telemetry never leaves the site.
Owning the detection and inference path is the strongest governance posture available to a distributed enterprise. Sensitive IT/OT and regulated data never leaves the site, so data-exfil and cross-border transfer risk are removed at the source. Controls map continuously to frameworks — NIST guidelines, sector standards such as FHIR for health data — producing continuous compliance evidence rather than point-in-time audits. No change to the detection model goes live until it has proven itself on cases it has never seen, and every change can be undone. A cloud detection set, by contrast, changes on the vendor's schedule. A live asset inventory (CMDB) tracks device firmware, end-of-life and protocol risk across the IT/OT estate, and the knowledge graph keeps identity, asset and vulnerability context joined.