AI Cut a 38-Minute Security Investigation to 89 Seconds—What Did Humans Give Up?

Sophos says AI agents reduced the average response time for cases using those agents from about 38 minutes to 89 seconds. It also says 52% of managed detection and response cases can now be resolved end to end by AI within boundaries calibrated by its analysts.

Those numbers are dramatic. They are also a vendor-and-customer case study, not an independent audit. The most useful lesson is not that every security team can become 96% faster. It is how Sophos decided what an agent may investigate, what it may recommend, and when a human must take over.

What the agents actually do

Sophos Fusion combines the company’s own products with more than 500 third-party integrations. According to the case study, those sensors generate trillions of events per day, which are reduced to roughly 1,000–2,000 cases for nine security operations centers.

An investigation agent gathers customer context, detections, indicators of compromise, and threat intelligence. A planning model then runs a plan-execute-review loop, completing investigative steps and producing a summary with recommended response actions. Other agents can perform parts of the response.

This is not a chatbot answering a security analyst. It is a constrained operational pipeline that has access to defined data and actions.

The distinction matters because it explains where the speed comes from. A general-purpose assistant waits for a person to paste in context, ask a question, and interpret the answer. A pipeline wired directly into telemetry and tooling can pull the relevant evidence itself, run the same checks an analyst would run, and assemble a summary without a human relaying information between systems. The plan-execute-review loop is the mechanism: the model proposes steps, executes them against bounded tools, then reviews what came back before moving on. That structure is what turns raw event volume into a defensible conclusion rather than a plausible-sounding guess.

It also explains the limits. The pipeline is only as good as the data it can reach and the actions it is permitted to take. Where integrations are missing or telemetry is thin, the agent has less to reason over, and the case is more likely to fall back to a person.

The number needs a denominator

The 38-minute-to-89-second comparison applies to cases using the agents. The public case study does not publish a full independent error analysis, the severity mix, the percentage of cases excluded before automation, or the cost of model inference and integration.

Sophos and OpenAI have strong incentives to showcase successful deployment. That does not make the result false, but it changes how the claim should be used. Buyers should ask:

1. Which case categories were eligible for automation?
2. What percentage required human correction or reopening?
3. How were false positives and missed indicators measured?
4. Does the 89 seconds include queues, approvals, and downstream action?
5. What is the cost per resolved case after compute and oversight?

Without those answers, the result is evidence of feasibility, not a portable benchmark.

There is a statistical point buried in the headline. A 96% reduction is only meaningful alongside the population it was measured on. If the automated cases skew toward well-understood, high-volume alert types, the comparison partly reflects case selection rather than pure model capability. That is not a criticism so much as a caution: the same pipeline applied to a messier mix of severities and edge cases would likely produce a less flattering average, and a fair evaluation would report both figures side by side.

The cost question deserves particular attention because it is the one most often left out of vendor announcements. Inference, integration maintenance, and human oversight all carry a price, and oversight does not disappear when cases are automated — it shifts from doing the work to checking it. A team that saves analyst minutes but spends them reviewing agent output, or pays for compute that exceeds the labor it displaces, has changed the shape of its operations without necessarily improving them. The right comparison is cost per resolved case end to end, not cost per model call.

The approval boundary is the real product

Sophos describes three customer operating modes. Notify means Sophos investigates and recommends while the customer acts. Collaborate means the parties work together before action. Authorise allows Sophos to respond on the customer’s behalf.

The company says the same boundaries apply whether the work is performed by a person or an agent, and potentially destructive actions retain human oversight when the team is not comfortable delegating them.

That is the architectural lesson. Faster reasoning does not create authority. An agent may be able to isolate a device, revoke access, block traffic, or alter configurations, but whether it should do so depends on reversibility, customer policy, confidence, and business impact.

An effective security agent therefore needs more than a model:

• explicit scopes for data and tools;
• customer-specific response policies;
• evidence attached to each conclusion;
• human escalation rules;
• idempotent and reversible actions where possible;
• audit logs for every step;
• continuous measurement of misses and corrections.

Each item on that list addresses a different failure mode. Scopes limit the blast radius of a wrong decision. Customer-specific policies encode the things a model cannot infer, such as which systems are too fragile to restart during business hours. Attached evidence lets a reviewer reconstruct why an action was taken rather than trusting a summary. Idempotent actions mean a retried step does not compound the damage. Audit logs make post-incident review possible at all.

What is notable about the three-mode structure is that it separates the question of capability from the question of permission. Many automation debates conflate the two: the agent can act, therefore it should. Sophos’s framing keeps them distinct, and the graduated modes give customers a way to expand autonomy as trust is earned rather than granting it all at once. That is a slower path to full automation, but it is also the path that produces evidence for the next expansion.

Why this use case fits agents

Security operations contain many repeatable investigations with structured inputs, known playbooks, and measurable outcomes. Analysts already gather context from multiple systems, compare indicators, check threat intelligence, and decide whether a case fits a familiar pattern.

That makes the work more automatable than vague knowledge tasks. The system can use deterministic checks around model judgment, and the highest-risk exceptions can be escalated.

The benefit is not merely headcount reduction. If routine cases are handled consistently, scarce analysts can spend more time on novel threats, ambiguous evidence, and decisions where business context matters.

Consistency is an underrated part of that argument. Human analysts vary in how thoroughly they check indicators, especially under queue pressure and at the end of a long shift. A pipeline that follows the same steps every time removes some of that variance, which is valuable even when the total number of cases is unchanged. The gain shows up as fewer skipped checks and fewer conclusions that depend on who happened to be on duty.

The risk is automation complacency. Attackers adapt. A pipeline optimized around yesterday’s case patterns can process the wrong conclusion very quickly. Teams need shadow testing, sampled human review, adversarial exercises, and rollback procedures even after the system appears reliable.

Complacency is subtle because it arrives as success. When a system resolves most cases correctly, reviewers naturally spend less time on each one, and the cases that need scrutiny are exactly the ones most likely to slip past a distracted reviewer. The countermeasures are organizational rather than technical: keep sampling a fixed share of automated cases regardless of how well the system is performing, run the pipeline against known-bad scenarios to confirm it still catches them, and rehearse rollback so that undoing an agent’s action is routine rather than an emergency.

Verdict

Sophos’s 89-second result is a compelling deployment signal, not proof that autonomous security is solved. The headline speed came from combining frontier models with private telemetry, established playbooks, tool boundaries, and human escalation.

The competitive advantage is not an agent that acts fastest. It is an agent that knows when it is allowed to act, preserves the evidence behind its decision, and hands uncertainty to a human before speed becomes damage.

For readers evaluating similar systems, the practical takeaway is to treat the speed figure as the beginning of a conversation rather than the end of one. Ask for the denominator, the error rate, and the cost. Then look at the approval boundary, because that is where the real engineering lives — and where the difference between a fast demo and a trustworthy operation is decided.