An AI pentester that runs the whole engagement.
A human signs the report.
Lory takes a signed scope, coordinates an autonomous multi-agent swarm, maps dynamic attack graphs (DAG), proves exploits with private OAST canaries, and drafts the report. Then a Lorikeet pentester countersigns it, and that signature is what your SOC 2, ISO 27001, or PCI-DSS auditor accepts.
What actually lands in your hands.
Not a dashboard you have to interpret. An engagement closes with the same artifacts a traditional pentest produces, plus two most firms can't give you: a record of what wasn't tested, and a machine-readable export your pipeline can consume.
The report
Executive summary, scope, methodology, findings with CVSS severity, remediation guidance and retest status, in the format CPA firms and certification bodies already accept.
Dynamic Attack Graph (DAG)
Visual exploit chaining modeling lateral movement, credential access, and cumulative blast radius from perimeter foothold to backend database or cloud IAM role.
Reproduction Replay Packs
1-click developer reproduction bundles generated for every vulnerability: raw cURL command, standalone Python 3 script, Postman Collection v2.1, and RFC 7230 .http.
Control mapping
Every finding carries its CWE and the control it breaks: Trust Service Criteria for SOC 2, Annex A for ISO 27001, and the equivalents for PCI-DSS, HIPAA, CMMC, GLBA and CIS.
Proof, per finding
The request and response that demonstrate the issue, screenshots where they help, and the chain it unlocked. A signal isn't a finding until it's been reproduced.
1-Click Surgical Retest
Verify individual remediated findings on demand in seconds without re-running entire engagements, with bidirectional sync to Jira Software and Linear tickets.
A coverage record
Vectors planned, vectors run, vectors never reached and the reason why. When your auditor asks what was tested, you hand them the answer instead of reconstructing it.
Retests and the fix trail
Auditors want evidence that findings were closed, not just found. File a retest from the portal or your terminal, and only a human closes a finding.
Machine-readable export
The same engagement as SARIF 2.1.0 for GitHub code scanning, or over MCP for your own tooling. Your findings stop living in a PDF nobody opens twice.
Where this sits against a scanner and a pentest firm.
Scanners are cheap and constant but prove nothing. Traditional engagements prove plenty but arrive twice a year, if the calendar cooperates. The point of an AI pentester is to take the frequency of the first and the evidentiary weight of the second, which only works if a qualified human still signs the result.
| Vulnerability scanner | Traditional pentest firm | LorikeetLory + a human pentester | |
|---|---|---|---|
| time to start | Immediate | Weeks, waiting on a tester's calendar | Same day you sign the scope |
| what you get back | Unvalidated signals to triage | Proven findings | Proven findings, plus what they chain into |
| business logic | Missed; no concept of your app | Covered | Covered; vectors chosen from live recon |
| evidence | A signature matched a pattern | Written up by hand | Captured request/response, screenshots, CWE |
| who signs it | Nobody | Your tester | Your tester. Lory drafts, a human countersigns |
| audit evidence | Rarely sufficient on its own | Accepted | Accepted, and pre-mapped to your framework |
| tells you what it missed | No | Rarely | Every run, with the reason attached |
| exploit chaining (DAG) | No; single-issue alerts | Manually documented | Dynamic Attack Graph (DAG) with visual blast radius |
| developer reproduction | Advisory links only | Written steps in PDF | 1-click Replay Packs: cURL, Python 3, Postman v2.1, .http |
| CI/CD security gate | Basic alerts | None (manual schedule) | GitHub Action, GitLab CI, & SARIF 2.1.0 gate on PRs |
| retesting | Re-run the scan | Often a new statement of work | 1-click surgical retests, synced with Jira & Linear |
| cost model | Annual licence | Fixed bid per engagement | Prepaid credits, no seats, no subscription |
If you'd rather skip the AI entirely, our pentesters will run the engagement by hand: same report, same signature, traditional timeline. That option never goes away.
Get your audit evidence in days, not a quarter.
SOC 2 and ISO 27001 stall on the same line item: independent evidence of technical security testing, dated inside the audit period, with findings triaged and retested. That evidence normally waits on somebody's calendar. Lory doesn't have one.
Scope and quote
You declare targets and sign the rules of engagement. Itemised quote back within 24 hours.
Lory runs
Recon starts the day the scope is signed. Depth sets the run length. No queue, because she doesn't have a calendar.
A human signs
A Lorikeet pentester reads the evidence, rates the risk and countersigns. The report goes out on our letterhead.
Fix and retest
Remediate, file a retest, and the closure evidence joins the audit file. This is the part to leave time for.
Why an AI report alone won't clear your audit
Auditors require independent testing by a qualified third party, documented. Raw autonomous output isn't that, and no auditor will treat it as one, which is the part most AI pentest tools quietly skip. Here the machine does the volume and a human does the attestation, so what you hand your auditor is a signed report rather than a tool export you still have to defend.
- who signs it
- SOC 2
CC7.1and ISO 27001A.8.8are satisfied by a qualified independent tester, not by software. If your auditor wants to talk to a human about methodology, they get one. - scope you can defend
- Auditors ask what was tested. The better ones ask what wasn't. The coverage record answers both. Most pentest reports simply can't.
- inside the period
- Type II observation windows and ISO surveillance audits both punish point-in-time testing. Credits are prepaid with no per-engagement contract, so re-testing after a major release is a same-week run, not a new procurement cycle.
| what she proves | SOC 2 | ISO 27001 Annex A |
|---|---|---|
| idor | CC6.1 · CC6.3 | A.8.3 |
| auth-bypass | CC6.1 | A.8.5 |
| sqli | CC7.1 | A.8.28 |
| ssrf → cloud creds | CC6.6 | A.8.20 |
| unpatched service | CC7.1 | A.8.8 |
| exposed admin panel | CC6.6 | A.8.9 |
| weak transport crypto | CC6.6 | A.8.24 |
| vulnerable dependency | CC8.1 | A.8.25 |
Worth saying plainly: a penetration test is one control in a framework, not the framework. Lory won't write your policies, run your risk assessment or sit your audit, and we are not your auditor. What she removes is the months you'd otherwise spend waiting on the one piece of evidence that has to come from outside your company.
Have an audit date already?
Tell us the date and we'll work the scope backwards from it, including time to fix what she finds.
One engagement, start to signed.
This is the actual shape of a Lory run: the same stages that show up in the log, in the same order. Nothing here is a metaphor for something else.
Scope is a gate, not a suggestion
You declare targets and sign the rules of engagement in the portal. Every single tool call is checked against that allowlist first. scope_check runs before anything touches a host, and an out-of-scope target is never contacted. Pick a depth: surface, standard or deep.
Deterministic sweep
Before any judgement calls, a fixed sweep establishes ground truth: DNS, live HTTP surface, service fingerprints, open ports, a screenshot. Same inputs, same output, every run, so the interesting part starts from facts rather than guesses.
Autonomous multi-agent swarm
Rather than a single sequential scanner, a specialized multi-agent swarm coordinates over a shared blackboard bus: Recon Specialist maps perimeters, Web & API Infiltrator deep-dives business logic and injection, and Cloud Hunter audits IAM privilege escalation chains. Dynamic model routing assigns fast vs deep reasoning tiers per task, maximizing depth while cutting token costs.
Validate with OAST, then graph the chain
A signal isn't a finding. Lory fires private Out-of-Band (OAST) canaries to confirm blind SSRF, XXE, and RCE without false positives. Verified footholds are chained into a Dynamic Attack Graph (DAG) mapping lateral movement into production databases, accompanied by 1-click reproduction replay packs (cURL, Python 3 PoC, Postman v2.1) and SARIF v2.1.0 exports.
A human signs, or it doesn't ship
Everything Lory writes lands in pending_review and stays invisible to you until a Lorikeet pentester reads the evidence and approves it. Risk rating, exploitation judgement, executive summary and final sign-off are ours. This is the part we won't automate.
What she can actually test.
You declare an asset, pick a depth of Surface, Standard or Deep, and Lory runs it. She covers every digital asset class we test — web apps, APIs, network perimeters, cloud environments, mobile applications, and connected source repositories. Physical security is the one engagement type Lory never runs (routed to human teams).
| engagement | who runs it | what it covers | prerequisites |
|---|---|---|---|
| web app · API | Lory | Crawl, authentication testing, injection, access-control checks, business logic, GraphQL, OpenAPI specifications, headless DOM XSS, and client storage leaks | Target URL, optional OpenAPI schema, test credentials for authenticated flows |
| network | Lory | External hosts and internal ranges through the mesh connector: service enumeration, exposure, CVE checks, and ephemeral Kubernetes containerized tool execution | Target hostname or IP/CIDR; Lory Mesh agent for internal network ranges |
| cloud & M365 | Lory | AWS, Azure, GCP, Microsoft 365 / Entra ID, Kubernetes, containers & serverless: IAM privilege escalation grapher (16+ privesc primitives), IMDS metadata, Conditional Access auditing, and lateral trust paths | Target cloud/M365 asset, read-only audit role or Graph API app registration |
| mobile | Lory | iOS and Android applications and the backends behind them: dynamic Frida runtime instrumentation, automated SSL pinning bypass (OkHttp, Conscrypt, SecTrust), root/jailbreak evasion, and cryptographic memory extraction | Mobile package (.apk / .ipa), TestFlight/Play access, or mobile API endpoint |
| source repo · CI/CD | Lory | Connected repositories and automated pipeline gates: GitHub Action & GitLab CI shift-left delta tests, SARIF v2.1.0 output, secret hunting, and SAST-style sink tracing | Connected repository (GitHub / GitLab access token) or CI/CD API key |
| physical | Human-led | Facility access control, badge cloning, tailgating, hardware drops. The one engagement type Lory never runs | Physical site authorization, signed rules of engagement |
The playbook library behind it
122 written playbooks across 14 categories. Lory doesn't carry one giant prompt: each attack class is its own playbook with methodology, payloads, false-positive traps and what proof looks like, and she loads exactly the one the current pass needs. Depth per vector instead of a checklist skimmed thin.
Web & API
32- sqli · nosql · rce · ssti
- ssrf · xxe · file-inclusion
- idor · business-logic · ast
- headless-dom · postmessage
- deserialization · race-condition
- graphql · websockets · cors
- prototype-pollution · waf-bypass
- + 15 more
Authentication
14- oauth · saml · jwt
- webauthn · mfa · mtls
- session-management
- account-recovery
- ntlm · ldap · legacy-sso
- api-auth · http-auth
- + 1 more
Cloud & M365
16- aws · azure · gcp
- iam-privesc-graph · trust-chains
- m365-conditional-access
- entra-id · ci-cd-oidc
- kubernetes · containers
- serverless · saas-security
- imds-ssrf · privesc-paths
- + 2 more
Network
14- external-perimeter
- network-layer · services
- credential-attacks
- windows-privesc · linux-privesc
- pivoting-tunneling
- ephemeral-k8s-sandboxing
- wireless · voip
- + 2 more
Active Directory
8- ad-recon · ad-credentials
- ad-privesc · ad-lateral-movement
- ad-persistence · ad-trusts
- adcs · kerberoasting
Mobile (Dynamic)
10- ios · android
- frida-ssl-pinning-bypass
- root-jailbreak-evasion
- crypto-memory-extraction
- data-storage · ipc-deeplinks
- resilience · mobile-backend
Recon & OSINT
10- osint-framework
- perimeter-discovery
- dns-subdomain-takeover
- certificate-transparency
- threat-intelligence
- exposed-credentials-hunt
- + 4 more
Autonomous Swarm
4- recon-specialist
- web-infiltrator
- cloud-hunter
- triage-validator
AI systems
6- prompt-injection
- llm-agents · rag-security
- mcp-security
- model-supply-chain
Code & supply chain
4- source-review · sast
- secrets-scanning
- dependency-vulnerabilities
- supply-chain-risk
Verification & Retest
4- surgical-1click-retest
- oast-canary-callback
- replay-pack-generator
- sarif-v210-gate
Operating rules
3- rules-of-engagement
- operator-identity
- findings-format
Desktop
1- thick-client
Utility
3- reporting
- fast-checking
- compliance-crosswalk
A code review needs a repository that is actually connected (provider plus access token), not merely registered. Which playbooks load is driven by engagement depth and what recon actually found, so a web-only scope never burns budget on Active Directory. Behind them sits a 1,969-entry vulnerability knowledge base built from OWASP ASVS, WSTG and Top 10 plus MITRE CWE and CAPEC, searched during enrichment so findings arrive with real remediation guidance rather than a generated paragraph.
We'll also tell you what she didn't test.
Every AI security tool shows you what it found. The harder number is what it never got to. Each engagement emits a coverage record: vectors planned, vectors that ran, and vectors cut short by the time or token ceiling, with the reason attached.
If a run stops two vectors short, that's in your engagement record and your pentester sees it before sign-off. You can raise the depth and rerun. What you can't do is mistake an unfinished run for a clean one.
Next-gen autonomous architecture.
Security isn't a linear script. Lory operates as an asynchronous, blackboard-coordinated intelligence swarm, combining deep multi-stage exploit chaining with non-destructive verification tools.
Autonomous Multi-Agent Swarm
Four specialized agent personas operate concurrently over a shared intelligence bus, handing off verified attack leads and optimizing model costs.
- Recon Specialist: Perimeter mapping & DNS permutations
- Web Infiltrator: IDOR, SQLi, SSRF, & business logic flaws
- Cloud Hunter: IAM privesc graphs & cloud metadata pivot
- Triage Validator: Retest verification & compliance mapping
Dynamic Attack Graph (DAG)
Models multi-hop exploitation as a real-time directed acyclic graph, linking isolated footholds into comprehensive lateral movement paths.
- Dynamic Mermaid visualization in portal dashboard & API
- Tracks harvested credentials & cloud IAM role assumptions
- Computes blast radius and critical paths to crown jewels
- Surfaces high-risk exploit pivot combinations instantly
Private OAST Canary Engine
Dedicated, out-of-band listener providing foolproof verification for blind server-side vulnerabilities without relying on guesswork.
- Verifies blind SSRF against internal cloud metadata (IMDS)
- Confirms blind XML External Entity (XXE) data exfiltration
- Detects out-of-band OS command injection via DNS & TLS canaries
- Cryptographically signed, unique canary tokens per probe
Dynamic Mobile Frida Harness
Automated runtime hooks for iOS and Android applications, dynamically neutralizing defensive controls to audit live mobile APIs.
- Android SSL Pinning Bypass (OkHttp 3/4, Conscrypt, TrustManager)
- iOS Pinning Bypass (SecTrustEvaluateWithError, NSURLSession)
- Root & Jailbreak Evasion (masks su, magisk, Cydia, substrate)
- Real-time cryptographic monitor dumping AES keys & plaintexts
CI/CD Gate & SARIF v2.1.0
Integrates autonomous penetration testing directly into your developer workflows before pull requests merge to production.
- Official GitHub Action & standalone POSIX CI runner script
- Configurable quality gate (
--fail-on high) blocks vulnerable PRs - Standard SARIF v2.1.0 alerts in GitHub Security Scanning
- Bidirectional sync with Jira Software and Linear tickets
Ephemeral Kubernetes Tool Sandboxing
Offloads heavy security tooling into isolated, on-demand container Jobs running on hardened Kubernetes infrastructure.
- Sandboxes Nmap, Katana, Nuclei, and Trivy in dedicated Pods
- Enforces least privilege: dropped Linux capabilities & no root
- Automated 60-second TTL garbage collection after job completion
- Eliminates host resource contention and memory starvation
Your engineers get the findings where they already work.
A test ends with findings; the work ends when the code changes. Native integrations put findings, reproduction packs, and automated gates directly in your tools.
In CI/CD pipelines
Block critical vulnerabilities before code merges. Run targeted delta penetration tests against staging targets and stream SARIF alerts into GitHub Security.
- Official GitHub Action (
action.yml) & POSIX runner - Customizable build-breaker gate (
--fail-on high) - SARIF v2.1.0 alerts on pull request diffs
- 1-click cURL and Python 3 reproduction packs
In the terminal
A Python TUI and CLI that pulls approved findings into the repo, points git grep at the lines responsible, asks Lory for the fix and files the retest.
- Traces findings to candidate lines by route & CWE sink
- Source is attached only if you opt in, per request
- 1-click surgical retests executed right in your shell
- It scans nothing; findings come from the engine, post-review
Inside your network
Internal testing without opening your perimeter. One command on one machine opens a single outbound, encrypted connection for Lory's full toolbelt.
- One install command, Linux, macOS or Windows
- Outbound only; no inbound port, appliance, or config
- Scoped to the engagement with a one-time token
- Ephemeral Kubernetes job runners for heavy tool loads
In your own AI tools
Point Claude, Claude Code, Cursor or any MCP client at your findings, DAG attack graph, replay packs, and vulnerability knowledge base.
- OAuth 2.1 or a workspace token, scoped per token
- Access hard-limited to your own company's data
- Exposes attack graph, replay packs, and compliance maps
- Billed at 0.1 credit per tool call
# 1. Run in your GitHub Action / GitLab CI pipeline - uses: Lorikeet-Security/lorikeet-security-platform@v1 with: api-key: ${{ secrets.LORY_API_KEY }} target-url: 'https://staging.acme-demo.com' fail-on: 'high' sarif-output: 'lory-findings.sarif' # 2. Or debug, replay, and retest in your shell lory findings list --severity critical lory replay 41 --format curl # 1-click cURL / Python reproduction lory retest 41 # Surgical retest. Only human countersign closes it.
Not ready to book? Ask her first.
No account, no form. Ask what an engagement would cost for your stack, what your SOC 2 evidence needs to cover, or what a finding in someone else's report actually means. Signed in she goes further, pulling your live findings, drafting an executive summary, scoping an engagement, or booking time with a human when you'd rather have one.
Prepaid credits. No seats.
Load a balance and Lory draws from it as she works. $1 buys 1 credit, MCP tool calls cost 0.1 credit, and engagements bill by depth. Credits gate the start of a run, so nothing begins that you haven't funded.
- ≈ 1,000 MCP tool calls
- Your first scoped engagement
- Every finding human-reviewed
- ≈ 2,500 MCP tool calls
- Multi-target, multi-stage chains
- Compliance-mapped reporting
- ≈ 5,000 MCP tool calls
- Room for deep, long-running runs
- Full vector coverage at depth
- ≈ 10,000 MCP tool calls
- Program-level, ongoing testing
- Priority human review
The things people actually ask.
What auditors require is independent testing by a qualified third party, documented, and that's satisfied by the Lorikeet pentester who scopes the run and signs the report, not by Lory herself. She's how the work gets done; the attestation is ours. Reports carry scope, methodology, severity ratings, remediation guidance and retest status in the format CPA firms and certification bodies already accept, plus a control mapping section: Trust Service Criteria for SOC 2, Annex A for ISO 27001. If your auditor wants to talk to a human about methodology, they get one.
A quote inside 24 hours, and recon starts the same day you sign the scope. There's no waiting on a tester's calendar, because Lory doesn't have one. Depth sets how long the run takes; human review and the write-up follow. The honest constraint isn't the testing, it's the fixing: auditors want to see findings remediated and retested, so scope early enough to close what she finds. For an ISO 27001 Stage 2 we'd still say test two to three months out.
It's prepaid and usage-based, with no subscription and no seat licences. Load credits ($1 = 1 credit), and Lory draws down as she works: 0.1 credit per MCP tool call, and engagements billed by depth. Preset packs run $100–$1,000, or set any custom amount from $25 to $25,000 in the billing tab.
No, and the workflow makes that structural rather than a promise. Everything Lory writes lands in a review queue and is invisible to you until a Lorikeet pentester reads the evidence and approves it. She covers volume: recon, validation, chaining, first-draft write-ups, round the clock. Scoping, exploitation judgement, risk rating and the final report are ours.
A scanner runs a fixed template set and hands you a list of maybes. Lory picks her attack vectors from what she found on your system, loads the matching playbook, proves the issue, and then looks for what it unlocks. The output is a demonstrated path with captured evidence, not raw signal you still have to triage.
Scope is enforced in code, not policy. Every tool call resolves its target against your signed allowlist before it executes, and an out-of-scope host is never contacted. Destructive tooling isn't in the toolbelt, a pentester oversees the run, and the full log of what was attempted is yours to read afterwards.
You're told. Every engagement records the vectors it planned, the ones it ran, and the ones it never reached because the time or token ceiling hit first. That record reaches your pentester before sign-off and reaches you in the engagement view. Raise the depth and rerun to close the gap.
For external testing, no. Lory runs entirely in the Lorikeet portal, and you can scope a run and have her starting recon the same day. Internal network testing needs one thing: the Lory Mesh connector, installed with a single command on one machine inside the network you want tested. It opens an outbound encrypted connection for the life of the engagement, so no inbound port is exposed and there is no appliance to rack. Separately, our MIT-licensed lk-exporter agent can sit on individual hosts to report patch state, inventory and supply-chain posture, but it is not what internal testing runs on.
Yes. The MCP server exposes your findings, assets, compliance posture and knowledge base to any MCP client: Claude, Claude Code, or your own. Auth is OAuth 2.1 or a workspace token, scopes are per-token, and access is hard-limited to your own company's data.
Rather than running a monolithic linear scan, Lory orchestrates four specialized agent personas collaborating over an asynchronous blackboard bus: a Recon Specialist (perimeter discovery and port sweeps), a Web & API Infiltrator (deep business logic, IDOR, and injection), an Infrastructure & Cloud Hunter (IAM privilege escalation and lateral movement), and a Triage & Validation Agent (PoC verification, OAST confirmation, and compliance mapping). Dynamic model routing tiers model complexity per task, optimizing speed and reducing token cost by 60–80%.
Yes. We provide an official GitHub Action and a standalone POSIX script (lorikeet-ci.sh) compatible with GitLab CI, CircleCI, and Bitbucket. You can configure a security threshold (e.g., --fail-on high), so if Lory discovers a high or critical finding during the pull request delta run, the build fails before code can merge into production. Findings are exported directly as standard SARIF v2.1.0 files to populate GitHub Code Scanning alerts.
For every confirmed vulnerability, Lory generates a 1-click reproduction pack for your engineering team. This includes a ready-to-run cURL command with escaped parameters and headers, a standalone Python 3 verification script with automated confirmation heuristics, an importable Postman Collection v2.1 JSON schema, and an RFC 7230 .http request. Developers can reproduce and verify the flaw in seconds in their own local environment without guessing.
Lory includes an automated dynamic mobile instrumentation engine powered by Frida (LoryFridaHarness). When testing iOS or Android apps, Lory generates custom Frida hooks on the fly to bypass SSL certificate pinning (for OkHttp 3/4, Conscrypt, TrustManager, and SecTrustEvaluateWithError), evade root and jailbreak detection, and monitor live cryptographic memory (intercepting AES keys, IVs, and decrypted payload buffers in real-time).
Once developers fix a vulnerability, you don't need to re-run the entire pentest. Lory's surgical retest engine replays the exact non-destructive verification payload against the specific finding in seconds. When integrated with Jira Software or Linear, marking a ticket "Resolved" automatically sends a webhook to Lory to trigger a surgical retest. When our human pentester confirms closure, the ticket status updates automatically.
Scope one engagement and see what she finds.
No waitlist and no separate contract. The AI pentester is live in the portal today. Book thirty minutes and we'll scope your first run together; if there's an audit date on the other end of it, we'll work backwards from that. Quote inside 24 hours, recon the day you sign.