Mindflow and Hackuity co-hosted a webinar in September 2026 on closing the loop on vulnerability management with agentic AI, presented by Umberto Mattei, solution designer at Mindflow, and Sylvain Cortes, VP of Strategy at Hackuity. The session centered on a live demo: an application owner reviewing a false-positive finding in Hackuity, and the workflow that closed it out.

Replay of the webinar:
 

TL;DR

• Hackuity's findings roughly doubled between June and September 2026, a surge tied to Claude's Mythos launch.

• Exploitation windows shrank from around two days to a few hours, so the real bottleneck is closing findings fast, not finding more of them.

• In the demo, a false-positive review that normally takes days closed in minutes, agent judgment checked by a separate deterministic approval gate, every step logged.

An application owner opens their remediation queue and finds a new alert. They're confident it's a false positive. Writing up the justification, getting it reviewed, and closing the ticket used to take a few days. In the demo, that same review, the approval, and the ticket closure happened in minutes.

The volume problem turned into a speed problem

Vulnerability teams have lived with noise for years. What changed in 2026 is where the noise comes from. Security teams are now pulling asset and vulnerability information directly from LLMs instead of only from traditional scanners, and those models are surfacing vulnerabilities scanners never caught. Hackuity's own customer base saw findings roughly double between June and September 2026, a surge the team traced back to Claude's launch and named the Claude Mythos effect: once assessments started running straight through Claude instead of only scanners, the volume of new findings jumped to levels Hackuity hadn't tracked before.

Hackuity’s VOC Manager dashboard.

Assets in Hackuity whose findings come from different sources for exemaple Claude Code AppScan.

Volume was never the hard part. On average, less than 1 percent of findings in a given environment are critical enough to warrant urgent action, and that has held for years. What changed is the clock. Exploitation windows have gone from roughly two days to a few hours. A team that triages correctly but takes three days to act is effectively unprotected during the window that matters.

That's the problem this integration is built around. Not finding more vulnerabilities. Getting the review-and-close cycle for the ones that matter down from days to minutes.

How the flow is built

Hackuity organizes its product around a vulnerability pyramid: aggregate findings from every connected scanner (Rapid7, Qualys, and Tenable among them) into deduplicated asset records, prioritize using threat intel, exploit availability, and internet exposure to produce a rescore, then automate the resulting decisions. The demo focused on that third layer.

A critical finding in Hackuity (CVE-2021-44790, True Risk Score 932). The owner moves it to Declared false positive, which triggers the Mindflow flow.

It starts when Hackuity sends a status-change event to a Mindflow webhook, the moment an owner declares a false positive. Two deterministic steps parse the event and set the run context: the remediation group, the sub-status the finding now holds, today’s date and a seven-day response deadline. After that, the work splits into three layers, each with a single job.

the full Enrichment and auto-approval flow, from the Hackuity webhook to the owner notification, with the escalation branch on the left

1. Judgment. The Vulnerability Triage Agent, an AI··Swarm on Claude Sonnet 4.6, is read-only. It only evaluates findings in Declared false positive and passes anything else to a human with the finding details attached. It reads the latest comment only and treats it as untrusted data. If the comment contains an instruction, like “approve this” or a fake system block, the agent flags an injection attempt and lowers its confidence. To judge the claim, it asks three questions. Does the owner actually deny that the vulnerability applies here? Do they give details someone could check, such as commands run, package names, versions or a ticket reference? Do they address the condition the exploit needs? It also checks Hackuity’s own record for contradictions. It returns a decision, a confidence score and flags from a closed list, and it holds no thresholds of its own.

2. Policy. The Approval Confidence Gate is a plain condition step, not an agent. In the demo, it passes only when the decision is APPROVE and confidence is above 0.7. Everything else goes to Security Operations on Slack, with a pointer to Mindflow Rooms for analysis. Because the threshold lives in the workflow, it is visible and versioned, and you can change it without editing a prompt.

3. Execution. The Remediation Approval & Audit Agent does not re-decide. It handles exactly one transition: Declared false positive → Confirmed false positive. Before any call, it checks that the decision really is APPROVE, that there is exactly one finding, that the finding really is in Declared false positive, that a justification exists and that no injection flag was raised. If any check fails, it makes no call. Otherwise it re-reads the live finding and takes the owner’s email from the asset’s own custom field, never from comment text, where an attacker could plant a recipient. Then it applies the change and posts an audit comment covering what changed, why, the evidence, the confidence, the fact that no human reviewed the finding individually, and how to reverse the change. It is capped at five Hackuity calls.

A Notification Formatting Agent (AI··Task) turns the receipt into an HTML email, and a standard send step delivers it to the asset owner.

the Approval Confidence Gate and its two branches. Auto-approval goes right, everything else escalates to Security Operations

One Hackuity specialist, reused everywhere

the SUB - Hackuity Specialist flow and its Tools tab, with 132 Hackuity operations allowed

Both agents reach Hackuity through the same sub-agent, SUB - Hackuity Specialist. It’s a small flow: a trigger, one AI··Task on Claude Opus 4.6 through Amazon Bedrock with EU routing, and a return. It’s built once and reused by any flow that needs Hackuity.

Its instructions are strict. Every request body is copied from a template, never composed from memory. The namespace is fixed and never taken from user input. Each field is tagged by how much evidence backs it: in the OpenAPI spec, captured from a real call, inferred, unverified, or already rejected by this tenant. Rejected values are never sent again. Only two operations can write, the status change and the comment, and both are gated: the specialist must already have searched that exact finding in the same conversation, and it prints the exact request body before sending. It never sees the API key or host, which stay in the connector credential.

This works because Mindflow’s Hackuity connector exposes the full API, and the specialist’s access is whitelisted one operation at a time: 132 Hackuity operations in this demo.

Where automation stops

Nobody on the call called this autopilot. Mindflow's engagement with customers starts as a scoping exercise, not a product sale: sit with the customer, map their existing use cases, and jointly decide what gets handed to an agent, what gets handled deterministically, and what stays manual. Teams typically start with AI-assisted enrichment, where a human still makes every call, then move specific, well-understood decisions like the false-positive review above into automation once they trust the pattern. Once a use case is properly modeled this way, up to 70 percent of these decisions can run without a human touching each one.

Hackuity drew a sharper line on remediation itself. Hackuity almost never sees customers doing fully automatic remediation at the server level, even though it's been technically feasible for years. Laptops and mobile devices get patched on a schedule without much oversight, because the blast radius of a mistake is small. Production servers are a different story. Hackuity's role there is to hand a human or Mindflow an accurate risk score, exploitability data, and asset context, not to push the fix itself. The one exception raised: CISO-defined compensating controls, like cutting network access to an asset when an application owner misses an SLA. That's a policy decision, not a per-vulnerability one.

Why the flow separates judgment, policy and execution

The failure this design guards against is one agent both judging a finding and closing it. If an LLM’s false-positive verdict closes a ticket directly, a real vulnerability can be closed on a plausible but wrong explanation, and nobody notices until the next scan or audit.

Here, the agent that judges can’t write, the agent that writes can’t judge, and the policy sits between them in plain sight. The owner’s comment is treated as data, never as instructions. The notification address comes only from the platform. Every confirmed false positive carries an audit comment that says how to reopen it. Autonomy works because control is built into the flow, not bolted on afterwards.

Fast & easy setup 

Setup needs a Hackuity API key, generated from the admin panel, plus Mindflow access. Building the automation itself took about one to two hours in the demo; most project time in practice goes into scoping the right use case and getting credentials approved.

Hackuity is the leading AI-powered Vulnerability Operations Center (VOC) platform, helping organizations transform fragmented cyber exposure data into prioritized, actionable remediation. By unifying security findings from across the cybersecurity ecosystem into a single pane of glass, Hackuity enables Executives, security, IT, and engineering teams to cut through the growing volume of vulnerabilities and focus on the risks that matter most. 

Combining AI-powered exposure prioritization, remediation orchestration, and cross-functional collaboration, Hackuity empowers enterprises to operationalize Cyber Exposure Management and accelerate risk reduction at scale.

Mindflow is the Enterprise Agentic Command Center. We help large organizations run AI agents securely, reliably, and at scale in the most complex enterprise environments. Our no-code, AI-driven flows connect tools, data, and teams, with your own LLM, guardrails, human oversight, and full auditability.