BLOGCritical vulnerability: OpenSSH authentication bypass on Alpine Linux

Agentic Tooling

AI agent security testing with proof behind every verdict

Detectify’s agentic tooling provides the verifiable trust layer your agents need to do their jobs safely, turning your security operations into an automated verification factory.

Instruct your AI agent to test each suspected issue, from SAST findings to bug bounty reports. It runs dynamic tests with Detectify's tested attack tooling, and every request lands in the Security Ledger as evidence it can't edit.

Book a demo

Why AI agents need a trust layer

DevSecOps teams have built software factories that ship code at speed. As AI writes more of that code, those factories now ship vulnerabilities at the same speed, and most of what static analysis flags is noise.

AI agents are good at reasoning, but they're built for efficiency and tend to cut corners.

Detectify gives your agents the trust layer they need to do this work safely, so you can run a verification factory next to your software factory.

What your AI agent is missing

A capable model can reason about an exploit. Models lack a specific workload and rely on potent but externally unverified attack vectors; however, the source of the proof is self-generated.

  1. 01A queue of structured workSuspected issues arrive as tickets.
  2. 02A call on what's worth testingA testability verdict with reasons. Your team can override it.
  3. 03Detectify's tested attack toolingThe same assessments as our DAST products. One check, a vulnerability type or a whole CWE. No full scan.
  4. 04A record it can't editThe tooling records what the agent did. The agent writes only its verdict.

How a verification factory works

Loop engineering for exploitability at scale

A verification factory is a loop that checks security findings as fast as your software factory produces them. Findings come in as tickets; your agent tests each one against the running app with Detectify's tooling, and the Security Ledger records the proof. Then it picks up the next one.

Instead of manually prompting a model at every step, you set up the loop once. Here is how your agents verify a standard SAST finding without a human in the loop.

Step 1

The trigger

Something triggers your SAST engine, a cron job, a CI pipeline running on a code change, or a daily alert.

Step 2

The inputs

Findings flow into a Detectify dashboard. This acts as the baseline inspiration, combining static analysis, bug bounty reports, and self-reported issues from your internal red team.

Step 3

Agent tickets

Every submission becomes an automated ticket, a single, focused task for your internal agent to verify.

Step 4

The agent steps in

Deployed inside your environment, the agent has full context. It can look at internal repos while simultaneously viewing the application from the outside like an attacker.

Step 5

Taking action

Deployed inside your environment with full context, the agent calls Detectify tooling via MCP servers to run real assessments against the web app and confirm if the finding is exploitable.

Step 6

The verdict

The agent files an outcome (Confirmed, Not confirmed, Inconclusive, or Not testable) and a summary. Your team reviews both in Detectify, linked to the ledger entries behind them.

Use the AI agent you already trust

Agentic Tooling works through MCP, so you can use agents such as Claude Code and OpenCode. Detectify doesn't host or run your agent: you keep your agent, your model, and your harness.

  • No new agent to adoptConnect the agent your team already uses. Setup is documented for Claude Code and OpenCode.
  • Your model, your costsYou choose the model, and your provider bills its usage, so you stay in control of what you spend.
Detectify Agentic Tooling
Connected agentClaude Code
Modelyours
Runs onyour machine
Toolsclaim · assess · browser · verdict
EvidenceLedger, written by Detectify

The Security Ledger: Evidence your agent can't edit

An agent's reasoning is probabilistic, but the record of what it actually tested is fixed. Agents evaluate their own runs, but the verdict that counts is the one the ledger supports.

  1. Verifiable work

    You never have to trust blindly. Every tool call, request, and payload is recorded so security engineers can check the agent's work against their own security standards.

  2. Full traceability

    The ledger ties directly back to the original tickets. See exactly what the agent did, the conclusions it drew, and the exact ledger entries that prove it.

  3. Inspect the evidence

    If an agent reports a vulnerability and the ledger shows no test behind it, the finding shows as unverified.

  4. A ledger for every source

    Scale your verification securely across SAST findings, open ports, bug bounty submissions, and other use cases like pentesting.

  5. Unmatched scale

    Deploy agents to investigate every single finding and reason around its severity in the context of your specific company. The Security Ledger ensures you can safely deploy that scale.

Verifiable work. You never have to trust blindly. Every tool call, request, and payload is recorded so security engineers can check the agent's work against their own security standards.

Vulnerabilities your AI agent can confirm with Detectify payloads

Classes confirmed with requests to the running app, plus a real browser for XSS. Including, but not limited to:

  • SQL injection (error-based)
  • OS command injection, code injection, SSTI, SSI/ESI injection
  • XML External Entity (XXE)
  • Cross-site scripting (reflected, with execution confirmed in the browser)
  • Open redirect
  • Path traversal, LFI, and remote file inclusion
  • Server-side request forgery (cloud and service metadata targets, reflected)
  • Authentication bypass, JWT weaknesses, session cookie flags
  • CRLF injection and HTTP response splitting
  • Security header and CORS misconfiguration
  • Sensitive data and information disclosure
  • SSL/TLS and certificate issues

FAQs

01What is a verification factory?

A verification factory is an automated loop for checking security findings. Suspected issues from SAST, bug bounty reports or your own team become tickets; AI agents test each one against the running app, and every verdict comes with evidence the agent can't edit. It's the security counterpart to a software factory: as code ships faster, findings get verified at the same pace.

Most of what SAST tools flag is noise: findings that may be technically true but aren't exploitable in your running app. Your agent tests each finding against the live app with Detectify's tooling, so you get a verdict with evidence instead of a long list to triage by hand.

Your agent runs on your side, on your model, and its traffic comes from your machine. Tickets that could cause harm, such as denial of service, are triaged as Unsafe, and marked by Detectify’s Agentic Tooling and a person decides further action. The evidence comes from Detectify's tooling, which the agent can't edit.

Detectify Agentic Tooling needs access to your source code within your environment to trace issues to where they are exploited in the running app. However, Detectify does not access or store your codebase; we only receive the final investigation data, ledgers, ticket contents, and request metadata. Note that SAST exports can include code snippets; if you'd rather not share those, you can describe the issues in plain text instead.

Partly. Your agent runs real attacks against a live system, but it answers a narrower question: is this specific suspected issue real? It works one issue at a time and gives you a verdict with evidence, not a pentest report.

Two products, one protocol. The MCP Server gives your agent Detectify's data and the saas product orchestration. Agentic Tooling gives it testing tools, a work queue of tickets, and an evidence record it can't edit.

Any agent that supports MCP (Model Context Protocol), with setup documented for Claude Code and OpenCode. SAST results upload as SARIF 2.1.0 or Semgrep JSON, in the app, from CI through the API, or by hand. You can also add bug bounty reports and self-reported issues.

Teams that already run agents (or are ready to), have a SAST backlog they don't trust, spend time on bug bounty retests, or want dynamic proof on top of SAST. It needs your own agent setup and a person to run it.

Ready to build your verification factory?

Give your internal agents Detectify's Agentic Tooling, and get the evidence you need to trust their verdicts.

Book a demoStart a trial