Penetration tests that cover more ground, led by an operator who has done it by hand.

Every penetration test is limited by hours. In an agentic test, AI agents take on the wide, repetitive work of mapping the attack surface, trying the known paths and re-checking fixes. That leaves the operator's time for the chained, context-dependent attacks that tools miss. Every finding in your report has been reproduced by a person.

The signed scope, as a map Two hostnames and the 256 addresses of 10.20.0.0/24 are in scope. The agent checked each one and found 23 hosts. 10.20.0.53, the production database, is excluded by name and was never contacted, and nothing in 10.20.1.0/24 was touched. One finding, on api.example.com, was reproduced by the operator. app.example.com api.example.com 10.20.0.0/24 .0 .16 .32 .48 .64 .80 .96 .112 .128 .144 .160 .176 .192 .208 .224 .240 10.20.1.0/24, outside the scope
Host foundNothing answeredExcluded by nameOutside the scopeFinding, reproduced

What we test

Web applications and APIs
Authentication, authorization, business logic and the paths between them. Tested against the OWASP Web Security Testing Guide and the OWASP API Security Top 10.
Networks
External exposure and internal movement, from the first foothold to what an attacker could reach. The method follows NIST SP 800-115 and PTES.
Cloud and identity
Misconfigurations, excess permissions and trust relationships across cloud accounts and identity providers. Attack paths are described in MITRE ATT&CK terms.

Rules of engagement

The terms every test runs under

  1. Written authorization comes first. No testing starts without a signed scope, a test window and emergency contacts.

  2. Agents stay in scope. Targets are checked against the authorization before an agent touches them, and every action is logged.

  3. A person validates every finding. Nothing goes into your report on an agent's word alone.

  4. Nothing disruptive without consent. Techniques that could affect availability or data need your approval in advance.

  5. AI use is disclosed. Your agreement names the AI tooling involved and explains how your data is handled.

The scope gate

This is rule 2 at work. Before a testing agent contacts anything, code checks the target against the signed scope. Try one.

In scope
app.example.comapi.example.com10.20.0.0/24
Excluded
10.20.0.53, the production database

Blocked.10.20.0.53 is excluded by name in the authorization. The agent stops and the attempt is logged.

An example scope. The check runs in your browser and nothing is sent anywhere.

Who does what

The agent

  • Maps the hosts, services and endpoints inside the signed scope
  • Checks them for known weaknesses and misconfigurations
  • Re-checks fixes after you have made them
  • Flags what it finds for the operator, with the evidence

The operator

  • Agrees the scope and the test window with you
  • Runs every exploit by hand; the agent does not exploit anything
  • Chains findings into the attacks that tools miss
  • Reproduces, rates and writes up every finding

Never without your sign-off

  • Any target outside the signed scope
  • Anything that could interrupt service or change data
  • Testing outside the agreed window

A harness we built ourselves

The testing agent runs inside a harness that Midnira wrote. Off-the-shelf autonomous testing tools let the model drive. For work on a client's live systems, we wanted the limits in code that we own and can show you. The model chooses what to look at next. Code decides whether it may.

Scope
Each target is checked against the signed authorization at the moment of contact. A name is looked up again every time, and the tool is given the approved addresses, not the name. What cannot be verified is refused.
Options
Every tool has a short list of options it may use and speed caps the agent cannot lift. Anything else is refused.
Pace
One rate budget covers every worker, so agents running in parallel cannot crowd a host.
Record
Every decision goes into the log, the refusals too, with the exact command that ran.

No exploitation or denial-of-service tools are wired into it. Its tests run without touching a network, and each stage of the build gets a security review before the next begins.

scope.pyThe check every address goes through

# ---- direct IP target -------------------------------------------------
if kind == "ip":
    ip = _canon_ip(host)
    if ip is None:
        return ScopeDecision(DENY, target, kind, host, [],
                             "unparseable IP target")
    chost = str(ip)   # canonical form, used as the rate-limit key too
    for net in scope.exclude_cidrs:
        if ip in net:
            return ScopeDecision(DENY, target, kind, chost, [chost],
                                 f"ip in exclude_cidr {net}", str(net))
    # a special/non-public IP is in scope only if explicitly included
    if _is_special(ip) and not any(ip in net for net in scope.include_cidrs):
        return ScopeDecision(DENY, target, kind, chost, [chost],
                             "special/non-public IP not covered by an "
                             "explicit include_cidr")
    for net in scope.include_cidrs:
        if ip in net:
            return ScopeDecision(ALLOW, target, kind, chost, [chost],
                                 f"ip in include_cidr {net}", str(net),
                                 scan_ips=[chost])
    return ScopeDecision(DENY, target, kind, chost, [chost],
                         "ip not within any include_cidr")

recon-runWhat the agent gets back

$ recon-run nmap 10.20.0.14 --dry-run -- -sV -p 443
[DRY-RUN] nmap 10.20.0.14 :: dry run (not executed)
        resolved: 10.20.0.14
        argv: nmap -sT -T2 --max-rate 100 --host-timeout 15m -sV -p 443 10.20.0.14

$ recon-run nmap 10.20.0.53 -- -sV
[REFUSED] nmap 10.20.0.53 :: scope: ip in exclude_cidr 10.20.0.53/32
        resolved: 10.20.0.53

$ recon-run nmap 10.20.0.14 -- --script vuln
[REFUSED] nmap 10.20.0.14 :: args: flag '--script' is blocked: NSE scripts are not permitted in the recon tier (flag for manual follow-up)
        resolved: 10.20.0.14

The code is copied from the harness as written. The output is the harness's own, run against the example scope above.

A sample finding, as it appears in a report

Invoice API returns other customers' records

Severity
High
Where
GET /api/invoices/{id}

What happened

Changing the invoice number in a request returned an invoice that belongs to a different customer. The server checks that the caller is signed in. It does not check that the invoice is theirs.

Steps to reproduce

  1. Sign in as test customer A and open any invoice.
  2. Note the invoice number in the request, then request the next number up.
  3. The response contains customer B's name, address and line items.

Fix

Check ownership on the server for every invoice request, and add a test that fails if one customer can read another's invoice.

Flagged by agent 3:18 AM Reproduced by operator 8:40 AM

What you receive

  • A report with reproducible steps and severity ratings
  • A prioritized fix list
  • A readout call with your team
  • A retest of the fixes
  • A signed attestation letter for auditors, insurers and customers

Ways to engage

Agentic penetration test
Agent-assisted and operator-led. More coverage inside the same test window, with every agent action logged.
Manual penetration test
Testing by hand, without AI tooling, for environments where it is not permitted.
Retests and recurring tests
Fixes are re-checked after remediation. Teams that ship often can book testing on a regular cadence.

What the test is used for

A SOC 2 audit
The report and the retest results show your auditor that an independent test was done and that the findings were fixed.
Cyber insurance
Insurers ask whether you test and when. A signed attestation letter answers that without handing over the findings.
Customer questionnaires
The attestation letter and the report summary give a customer's security team what they ask for.

A penetration test supports these requirements. It does not by itself make a company compliant.

How a test runs

  1. Scoping call

    30 minutes

    We agree what is in scope, what is left alone and when testing can happen.

  2. Authorization

    You sign the scope, the test window and the emergency contacts. Nothing starts before this.

  3. Testing

    One to two weeks

    The agent and the operator work inside the window. You hear about a high-severity finding the same day.

  4. Report

    Within five business days

    Findings with steps to reproduce, severity ratings and a prioritized fix list.

  5. Readout

    A call with your team to walk through the findings and the fixes.

  6. Retest

    Within 60 days

    We check that the fixes hold and update the report.

What we need from you

  • The applications, hosts and addresses in scope, and anything to leave alone
  • Test accounts for each role we should test
  • A test window, and who to call if something looks wrong
  • A signature from someone who can authorize testing of these systems

We give you the address the testing comes from, so your team can recognize it.

How we price

A fixed price for a defined scope
Quoted in writing after the scoping call. One retest of the fixes is included.
What sets the price
The number of applications, user roles, addresses and cloud accounts, and how deep the testing goes.

The questions buyers ask, answered.

Is it safe to run on production?
Yes, with limits. The agent maps and checks for known weaknesses at a controlled rate. Anything that could interrupt service or change data needs your approval in advance, and you choose the test window. We can also test a staging copy if you have one.
Who checks what the agent finds?
The operator. Every finding in your report has been reproduced by hand, so an agent's false alarm does not reach you.
What does the AI provider see?
The agents run on Claude, the AI model made by Anthropic. Test data that passes through the agents is not used for model training. Your agreement names the AI tooling and explains how your data is handled, including how long the provider keeps it.
Can you test without AI?
Yes. A manual test uses no AI tooling, for environments where it is not permitted.
How is this different from a vulnerability scan?
A scan lists known weaknesses. A penetration test shows what an attacker can do with them: which can be exploited, how they chain together and what they expose. Each finding comes with the steps to reproduce it.
How long does it take?
Most tests run one to two weeks, and the report follows within five business days. The scoping call sets the dates.
Is a retest included?
Yes. One retest of the fixes is included in the price.

Tell us what you want handled, or what you want tested.

Send a few lines about the work, or book a 30-minute call. A person reads every message and replies.