Security Copilot EssentialsIntermediate15 min

Embedded in Defender, Sentinel, Entra, and Purview

Route an investigation to the product that owns the evidence, classify every finding as confirmed, plausible, or unknown, and treat generated KQL and guided response as drafts that require analyst review.


What you'll learn

  • Route an investigation to the product surface that owns the evidence
  • Classify embedded findings as confirmed, plausible, or unknown
  • Validate generated KQL as a draft before running or interpreting it
  • Correlate findings across products without turning proximity into causation
On this page

Entra flags a risky sign-in. Intune holds the device record. Eight minutes later, Purview raises a data-loss alert for the same user. The records may be related, but three nearby events don't establish one incident.

Embedded Security Copilot starts inside the product record you already have open. Your job is to begin with the product that owns the evidence, carry identifiers carefully between records, and stop a neat account from becoming stronger than the underlying data.

Which surface owns the evidence?

When you begin from a record, the product that holds that record should anchor your reasoning. Defender XDR and Sentinel both summarize incidents, but they diverge past that point, and Entra, Intune, and Purview each own a different slice of the picture. Route by asking what owns the evidence you need:

Investigation need Start in
Summarize an incident Defender XDR or Sentinel
Analyze a file or script Defender XDR
Summarize a device or identity Defender XDR
Generate a hunting query (KQL) Defender XDR, or Sentinel (Preview)
Guided response on an incident Defender XDR
Investigate a risky user or application Entra
Query a device or its policies Intune
Investigate a DLP or insider-risk alert Purview

Reliability here comes down to two things. First, treat the incident or product record as the authoritative source for identifiers, timestamps, and entities. Don't treat Copilot's prose that way. Second, don't assume a capability that exists in one surface exists in the other: Defender XDR analyzes files and scripts and offers guided response, while Sentinel's documented strengths are incident summaries and natural-language-to-KQL. Misrouting costs more than time: ask a surface a question it doesn't own and you may get a confident answer built on the wrong evidence, or a thin one built on almost none. Choose the surface that owns the evidence, and match the returned incident identifier to your own notes before you trust anything else in the response.

Three finding states

Embedded investigations use three labels that work well across products. Mark each material statement Confirmed when an identified record directly supports it, Plausible when it is a reasonable interpretation that still needs checking, or Unknown when the available records don't establish it. These are analyst-applied labels. Copilot doesn't return them as a built-in field, and precise wording isn't evidence.

A documented capability also doesn't guarantee that a particular record contains every requested field. An Intune device record may omit compliance state. A Purview DLP alert may identify a user while leaving out the device or destination. Ask for those fields, but tell Copilot what to do when they are absent: "Use only fields available in the selected record. For each requested field that is absent, return Not available, and do not infer a value."

Classification matters after the first review because statements move. A Confirmed line may be copied into a case record or used by an analyst who never opened the source alert. If a Plausible interpretation is promoted to Confirmed, the later decision rests on evidence that wasn't present. Keep the weaker label until another record closes the gap.

Ask for "Not available" when a field is missing

Add one line to every embedded prompt: "For each requested field that is absent, return Not available. Do not infer a value." Without it, a missing device or destination gets filled with something plausible, and now your case record contains a fact the source never supported.

The evidence-first Defender XDR summary· security-copilot
Bad example

Summarize this Defender incident and tell me what happened and what we should do next.

Good example

Summarize the selected incident for a SOC analyst. Return the incident identifier and title, a timeline of observed activity, affected users, devices, files, and scripts, alerts and evidence, current hypotheses, unknowns and missing evidence, and three prioritized next checks. Label every substantive statement as Evidence, Hypothesis, Recommendation, or Unknown. Do not present an inference as an observed fact.

Why this works: A labeled summary anchored to the correct incident, where you can match the returned identifier to your notes and see exactly which statements are evidence and which are the model's interpretation.

A bounded Purview DLP investigation· security-copilot
Bad example

Investigate this DLP alert, explain the risk, and take any necessary action.

Good example

Investigate the selected Purview DLP alert during [time range and time zone]. Use only evidence available in the current Purview context. Return the record ID, timestamp, user, policy signal, data category, destination, and device context when present. Mark unavailable fields "Not available." Separate observed evidence from risk interpretation, classify each conclusion as Confirmed, Plausible, or Unknown, and give one read-only verification step. Do not close the record or change a policy.

Why this works: A DLP finding where the destination and device stay "Not available" if the record doesn't hold them, the interpretation is labeled Plausible, and no alert is closed on your behalf.

Generated KQL starts as draft

Ask Copilot to turn a hunting question into a Kusto Query Language (KQL) query and you'll get syntactically valid text in seconds. Syntactically valid text can still be wrong. Generated KQL does not establish that the proposed tables hold the data, that the fields exist in your environment, that the time filter matches the incident, that entity values use the right format, or that the returned rows support your hypothesis.

Run it through a short validation loop before you interpret a single row. Confirm the full date, time boundary, and time zone: "between 09:00 and 10:00" with no calendar date is ambiguous and unsafe. Check the proposed tables and fields against your available schema. Decide whether the logic needs both entities in one record (AND) or either entity (OR), because that changes the meaning entirely. Then run the query in the authorized query experience, compare the returned records against the incident timeline, and revise only the condition that proved defective.

Sentinel's natural-language-to-KQL is documented as Preview. That status doesn't mean the output is unusable, but you still need to check the schema, the logic, and the result before you rely on it.

Preview means validate it yourself

Sentinel's natural-language-to-KQL capability is in Preview. Preview status doesn't tell you the output is wrong. It tells you to verify the schema, the logic, the execution, and the returned rows yourself before the results support any conclusion.

Generate a query that shows its assumptions· security-copilot
Bad example

Write a KQL query to find activity from this user and device around the incident.

Good example

Generate a Defender XDR KQL query to test whether the selected user and device have activity relevant to this incident during its recorded time window. Before the query, list the assumed tables, the assumed timestamp, user, and device fields, the exact time boundary and time zone, the entity-value formats, and any required telemetry that may be unavailable. Explain each major condition. Do not invent missing identifiers.

Why this works: A query preceded by its own assumption list, so you can verify tables, fields, time boundary, and entity logic against your schema before you run it, and reject any assumption that doesn't hold.

Correlation across products needs proof

Separate embedded sessions don't automatically share prior findings. Use a manual worksheet for correlation, with one row per source and columns for the product, exact record ID, user, device, timestamp, confirmed evidence, interpretation, missing evidence, and correlation status. Move identifiers and findings into it deliberately.

A cross-product relationship is defensible when the identifiers and relevant times align and the records support the link. Suppose Entra and Purview both identify [email protected], while Entra and Intune both identify device WIN-ENG-042, with events minutes apart. The shared user and device are Confirmed. If the Purview alert has no device field, you still can't place the DLP activity on that machine. That link remains Unknown, and a single common compromise remains Plausible until another record supports it. Nearby timestamps support a hypothesis. They don't establish causation.

Nearby in time is not caused by

Two events eight minutes apart, sharing a username, invite the story that one caused the other. Resist it. Until a record ties them together (a shared device, destination, or activity), the relationship is Plausible at most, and stating it as Confirmed is how a wrong conclusion enters a case file.

Recommendation is not authorization

Defender XDR's guided response suggests steps for an analyst to consider. It doesn't approve them. A recommendation such as "isolate the device" may read like an instruction, but the tool doesn't know your change process and has no authority to carry out the action. Before changing a user, device, file, or policy, verify the target, preserve the supporting evidence, understand the expected effect and blast radius, and obtain the required approval.

Record proposed actions as "awaiting approval." Mark one complete only after the action occurred and an authorized person signed off. A later reviewer should be able to distinguish what the evidence established, what the analyst recommended, and what the organization approved.

Try it yourself

Correlate three records without inventing a link

Practice the core embedded skill on a synthetic set: confirm what aligns, and refuse to confirm what doesn't. Five to ten minutes, no tenant needed.

  1. 01

    Take these three synthetic records. Entra: [email protected], device SURFACE-118, 14:03 UTC. Intune: device SURFACE-118, policy SALES-BASELINE, 13:48 UTC, reported state "Needs review," user field absent. Purview: DLP alert DLP-882, [email protected], 14:11 UTC, device and destination absent.

  2. 02

    Write the exact identifier matches: which user is shared across which records, and which device is shared across which records.

    Hint: Intune has no user field and Purview has no device field. Note both gaps rather than papering over them.

  3. 03

    Normalize the three timestamps to UTC and compare the windows without claiming that closeness proves causation.

  4. 04

    Write two Confirmed statements, one Plausible statement, and two Unknowns, then choose one read-only next check that could close a gap.

A correlation conclusion that confirms the shared user and device, keeps the Purview device and destination Unknown, rates a common incident as Plausible, and proposes a safe next check, with no account disabled and no policy changed.

Key takeaways

  • Start in the product that owns the evidence. Don't assume one surface's capability exists in another.
  • Classify embedded findings as Confirmed, Plausible, or Unknown, and mark absent fields "Not available."
  • Generated KQL is a draft. Validate tables, fields, date, time zone, and AND/OR logic before interpreting results.
  • Separate sessions don't share evidence. Correlate through a manual worksheet using exact identifiers and aligned times.
  • Guided response and any recommendation inform a decision. They never authorize an action.

Check your understanding

  1. 1. Entra and Intune name the same device, Entra and Purview name the same user, but the Purview alert lists no device. Does this confirm one common compromise?

  2. 2. Copilot produces a hunting query for activity "between 09:00 and 10:00" but states no calendar date, tables, fields, time zone, or AND/OR logic. Is it ready to run and interpret?

  3. 3. You need to analyze a suspicious script that's part of an incident. Which surface is the documented place to do it?

  4. 4. A documented Purview capability returns a DLP alert, but the record has no destination field. How should your prompt handle it?

  5. 5. Guided response recommends isolating a device. Is that recommendation authorization to isolate it?

Frequently asked questions

Terms used in this lesson

embedded experience
Security Copilot used inside another security product, starting from that product's incident, identity, device, or alert context.
entity
An object involved in an investigation, such as a user, device, account, file, or script.
KQL
Kusto Query Language, the query language used to search security telemetry in Defender XDR and Sentinel.
guided response
Defender XDR recommendations for responding to an incident. They inform a decision. They don't authorize action.
correlation
Linking findings across products using exact identifiers and aligned times, only when the records support the relationship.

Further reading