skip to content

A SOAR playbook's host-isolation step returns success — what does that actually prove?

level: juniorimportance: must knowfreq 68%

answer

  1. a request accepted, not a state achieved
  2. the agent still has to check in
  3. pending containment is not containment
  4. verify at the target, not the platform

basics

~20 s

Only that the EDR's API accepted the isolation request. The host is cut off once its agent checks in and applies the policy; an offline or dead agent leaves the request pending, so verify containment in the EDR's own host record.

solid answer

~40 s

A green step means the response platform got a 2xx from the EDR connector — the request was accepted, not that the endpoint is off the network. Enforcement happens later, when the agent next checks in and applies the containment policy, which usually still allows traffic to the EDR's management channel. If the agent is offline, has been killed by the intruder, or the machine is an ephemeral CI runner that no longer exists, the request can sit pending indefinitely while the run log says success. So I verify at the target, not at the automation: read the EDR's host record for a confirmed containment state, and ideally confirm from telemetry that the host is no longer reaching anything else. Until that confirmation, the incident timeline records the host as uncontained.

go deeper

for a junior

Be ready to say plainly that a successful API call means the request was accepted, not that the host is off the network, and to name where you would look to confirm it.

for a middle

Explain the mechanics: the console holds desired state, the agent enforces it at check-in, and an offline or tampered agent leaves the action queued while the run still reports success.

for a senior

Show the operational habit — two timestamps in the timeline, a fallback network-level containment path when the agent will not confirm, and treating a stalled containment as a signal about the host.

for a principal

Own the standard: define what evidence your SOC accepts before anyone may say a host is contained, and accept the cost that this verification adds to every automated response path.

## Three claims that look identical in a run log When a playbook in a response platform such as Cortex XSOAR or Tines executes an isolate-host action, three different things might be true, and only the weakest is evidenced by a green step: 1. **The platform sent the request and the EDR's API accepted it.** This is what an HTTP 2xx response and a completed task record. 2. **The EDR has recorded the intent to contain that host** — visible in its console as a state such as `containment pending`. 3. **The host is actually cut off** — its agent has checked in, received the policy, and now drops traffic to everything except the EDR's own management channel. The automation's execution record can only ever evidence (1). Everything a responder cares about lives in (3). ## Why the gap exists Endpoint isolation is not something the console does to the network; it is something the *agent on the host* does to itself, on instruction. The console holds a desired state and hands it out at the agent's next check-in. That interval is normally seconds to a few minutes and is invisible when nothing is wrong. It becomes very visible when: - the machine is powered off, suspended, or on a network the agent cannot reach — the containment is queued, not applied; - the agent process has been stopped, tampered with, or its driver unloaded — the console may still show a stale "last seen" and accept the request forever; - the host is ephemeral. A container-based or autoscaled CI runner may already have been destroyed and replaced, so the isolation applies to an identifier that no longer maps to a running machine — and to nothing that matters; - the connector's credential is valid for the API but the account lacks the containment permission, so some deployments return an accepted-then-rejected pattern. ## Why the distinction is not pedantry with an intruder present The minutes between "request accepted" and "policy enforced" are minutes during which an adversary with hands on the keyboard is still able to act: finish staging data, drop an additional persistence mechanism, or notice the attempt and pivot. An adversary who sees an isolation attempt coming often behaves very differently from one who does not, so this window is exactly where the case is won or lost. Recording it as contained means every subsequent finding is reasoned about against the wrong assumption. It also matters for the claim you will eventually have to defend. "The host was contained at 03:14" is a statement about the world. If the only support for it is a playbook task that finished, the statement is unsupported. ## How to verify properly Use evidence produced by the target, not by the automation: - **The EDR's host record** — a confirmed containment state with its own timestamp. This is the minimum bar, and it is what your case timeline should quote. - **Independent telemetry** — the host's network connections stopping, or flow records showing the host reaching only the EDR's management endpoints. Note what a flow record can and cannot tell you: it shows that bytes stopped moving, never what they were. - **A second control path** — if the agent will not confirm, fall back to a network-level quarantine (switch port, network access control, or, for a cloud instance, a restrictive security group). This does not depend on the compromised host cooperating. ## What to write down Record two timestamps, always: when the containment action was *requested*, and when containment was *observed*. The distance between them is a real quantity in the incident — it bounds what the adversary could still do — and it is also the number that shows whether your response tooling is as fast as your report claims. If containment is never observed, the case says so; a pending state is not a contained state, and no amount of green in the run log converts one into the other. ## The general rule this teaches Automation records what it *attempted*. Targets record what *happened*. Any verdict about the state of the estate must be sourced from the second. This applies well beyond isolation: disabling an account, blocking a hash, quarantining a build artifact — in every case, the proof is the target system's own audit entry, not the step that asked for it.

  • The EDR shows the host as containment pending for twenty minutes during a live intrusion. What do you do while you wait?
    Treat the host as uncontained and reach for a control that does not need the host's cooperation: a switch-port or network access control quarantine, or a restrictive security group for a cloud instance. Keep watching the host's telemetry, because a stalled containment is itself a signal — the agent may have been stopped deliberately. Record both timestamps in the case.
  • Why is the EDR console's host record better evidence than your playbook's run log?
    The run log records what the response platform sent; the console records what the target system believes it applied. They disagree whenever a connector, permission, or agent fails. The strongest evidence is a third, independent signal — telemetry showing the host now reaches nothing but the EDR's management channel.
  • Your playbook isolates a CI runner rather than a laptop. What extra check does that need?
    Confirm the identifier still maps to a live machine. Autoscaled or container-based runners are destroyed and replaced constantly, so an isolation can be accepted for a host that no longer exists while a fresh runner picks up the next job. Check the runner's lifecycle state in the build system before trusting the isolation at all.

It is the difference between the postal service accepting your letter and the recipient reading it. The receipt proves only the first.

saying these in an interview costs you the question

  • Says a 200 from the EDR API means the host is off the network
  • Quotes the playbook run log as proof of containment
  • Assumes isolation is instantaneous and cannot be pending
  • Records a pending containment as contained in the timeline
  • Confuses isolating a host with removing the intruder's tooling

context