Request demo
Back to AI SOC

November 18, 2026

AI SOC architecture: the four layers between ingest and verdict

Most AI SOC platforms look alike at the console. The differences are in how the environment is represented, where the reasoning happens, and what the agents act on. A layer-by-layer guide, with Exaforce's stack as the worked example.

An AI SOC architecture has four layers: a data layer that ingests and gives events context, a reasoning layer that decides what an event means, an execution layer of agents that triage, investigate and respond, and a surface where analysts read the evidence and approve actions. Most platforms look alike at the console. The differences that decide whether verdicts are consistent, explainable and affordable at scale sit between ingest and verdict, in how the environment is represented and where the reasoning happens. This guide sets out what each layer has to do, what to check in a demo, and how Exaforce, which publishes this page, builds each one.

What an AI SOC architecture has to do

Three failures show up in production when the architecture is wrong. A model that reads raw logs at query time cannot hold memory across a long investigation, so it loses the thread. The same alert gets a different answer on different runs, so analysts stop trusting it. And cost rises with the data the model has to read, so coverage gets cut to control spend. The layers below exist to prevent those three outcomes.

LayerThe question it answersWhat to check in a demo
Data and contextWhat is this event, about whom, on what?Ask what an IP, a token and a repository push become at ingest. If the answer is "a log line", context is built later, per query, at cost.
ReasoningIs this normal, and what does it mean?Run the same alert twice. Ask which model handled entity resolution, which handled behavior, and which wrote the summary.
AgentsWhat should be done, and by whom?Ask what happens when a connected tool's API changes. A playbook breaks; an agent reasons about it.
Analyst surfaceCan a person audit this and act?Open a closed case and follow the reasoning to the evidence without the person who ran it.

Layer 1: data and context

The data layer ingests events in real time, deduplicates, normalizes and correlates them, and tiers storage so retention stays affordable. The architectural choice is what happens next. One design stores the raw text and lets a model read it when a question is asked; it is simple and it is the source of all three failures above. The other resolves each event against structured context as it arrives: an IP becomes a known host, a token becomes a known service identity, a repository push becomes an action by a known engineer on a known asset. Everything downstream reasons over entities and relationships rather than strings. Ask which design you are looking at before anything else.

Layer 2: reasoning

The reasoning layer decides whether the activity is normal and what it means. A single large language model can do this for one alert; it struggles to do it consistently for a million. The more robust design splits the work across models with different jobs: one that resolves entities and relationships and keeps a living map of the environment, one that learns what is normal for each human and machine identity, application, resource and location, and one that synthesizes the findings into something a person can act on. The split is what keeps memory across a long investigation, makes two runs agree, and keeps cost from scaling with raw data. See transparent reasoning in an AI SOC for how to test it.

Layer 3: agents

The execution layer is where "agentic" is earned. Agents should be task-specific, each scoped to one part of the lifecycle, and should reason from the context the lower layers built rather than from hardcoded scripts, so that a changed API or an unfamiliar sequence is something to reason about instead of something that breaks the run. The contrast with SOAR playbooks is the point: a playbook executes steps a human designed; an agent carries the judgment. Human oversight belongs here too, as approvals the team configures per action type. See SOAR vs AI SOC.

Layer 4: the analyst surface

The top layer is where analysts read verdicts, approve actions, hunt and ask questions. Its architectural requirement is that the evidence is in the case, not in the model's context window: a second analyst, an auditor or a customer should be able to follow the reasoning from the verdict to the raw events. A query interface over the same data, in natural language, is what makes hunting and investigation one activity instead of two.

How Exaforce builds the four layers

Exaforce is an agentic SOC platform built on the second design at every layer.

  • Data platform. Ingests logs, identity data, configuration and code from 130+ sources, deduplicates, normalizes and correlates them at cloud scale with tiered storage, and resolves each event at ingest against a model of identities, resources and their relationships. Its own detections run on that model. See the platform.
  • Multi-Model AI. Three models rather than one: a Semantic Data Model that resolves entities and relationships and maintains the map of the environment, a Behavioral Model that learns normal activity across human and machine identities, applications, data, resources and locations, and a Knowledge Model that synthesizes context into actionable findings. See Multi-Model AI.
  • Exabots. Five task-specific agents working under analyst oversight: Exabot Detect, Exabot Triage, Exabot Investigate, Exabot Respond and Exabot Hunt, each reasoning from the shared model, with the reasoning shown on every verdict. With ExaU, teams build their own Exabots for the work specific to them. See Exabots.
  • Analyst surface. The Advanced Data Explorer, a natural-language query interface over logs, identity, configuration, code and threat intelligence, and ExaGo, the same console on a phone for notifications, escalations and approvals. Coverage spans identity, IaaS, SaaS, endpoint, email and insider risk.

Customers report 90% fewer false positives and a 95% reduction in mean time to investigate, with an average of under 30 minutes from alert to response. Teams run the platform themselves or have Exaforce MDR run it on the same architecture.

Using this in an evaluation

  1. Ask the data-layer question first; it predicts the answers to the rest.
  2. Run the same alert twice and compare the verdicts.
  3. Break an integration on purpose in the pilot and watch what the agents do.
  4. Hand a closed case to someone who did not run it and time how long they take to agree or disagree with the verdict.

See the top features of an AI SOC platform for the feature-level checklist that sits on top of this one.

Frequently asked questions

What is an AI SOC architecture?

The set of layers that take a security event from ingest to an explainable verdict and an action: a data and context layer, a reasoning layer, an agent layer and an analyst surface. The design choices inside each layer decide consistency, explainability and cost.

Does an AI SOC need its own data layer?

To replace a SIEM, yes; to investigate alerts a SIEM raises, no. A platform without a data layer inherits the coverage and quality of the tools beneath it.

Why not one large language model?

One model reading raw logs loses memory across long investigations, answers the same alert differently on different runs, and costs more as data grows. Splitting the work across models with distinct jobs, over context built at ingest, avoids all three.

Where does the human sit in an AI SOC architecture?

At the analyst surface: reviewing verdicts with the evidence attached, approving the actions the team chooses to gate, and giving the feedback the detections and agents learn from.

What is the difference between an AI SOC architecture and a SOAR architecture?

SOAR executes playbooks a person wrote; an AI SOC's agents reason from context the platform built. See SOAR vs AI SOC.