Skip to main content
Audit-ready evidence · signed by a human pentester · Multi-agent swarm

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.

Reports mapped to
Lory, the Lorikeet Security AI pentester
24hr
to an itemised, scoped quote
Same day
swarm recon starts once you sign scope
122
attack playbooks across 14 categories
31
sandboxed tools & ephemeral K8s runners
0
findings reach you without a human signature
deliverables

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.

Interactive Mermaid · visual chain

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.

cURL · Python 3 · Postman v2.1 · .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.

7 frameworks · no hand-mapping

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.

reproducible · not a signature match

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.

Jira · Linear · isolated re-validation

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.

emitted every run

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.

no new SOW required

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.

SARIF · MCP · JSON
how it compares

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.

SOC 2 & ISO 27001

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.

Day 0

Scope and quote

You declare targets and sign the rules of engagement. Itemised quote back within 24 hours.

Day 0–1

Lory runs

Recon starts the day the scope is signed. Depth sets the run length. No queue, because she doesn't have a calendar.

Then

A human signs

A Lorikeet pentester reads the evidence, rates the risk and countersigns. The report goes out on our letterhead.

Before fieldwork

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.1 and ISO 27001 A.8.8 are 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 provesSOC 2ISO 27001 Annex A
idorCC6.1 · CC6.3A.8.3
auth-bypassCC6.1A.8.5
sqliCC7.1A.8.28
ssrf → cloud credsCC6.6A.8.20
unpatched serviceCC7.1A.8.8
exposed admin panelCC6.6A.8.9
weak transport cryptoCC6.6A.8.24
vulnerable dependencyCC8.1A.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.

engagement

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.

engagement #27 depth=standard running
every tool call logged every vector accounted for nothing outside scope
01

Scope is a gate, not a suggestion

you + our team

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.

02

Deterministic sweep

lory

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.

03

Autonomous multi-agent swarm

lory swarm personas

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.

04

Validate with OAST, then graph the chain

lory

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.

05

A human signs, or it doesn't ship

our pentesters

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.

coverage

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).

engagementwho runs itwhat it coversprerequisites
web app · APILoryCrawl, authentication testing, injection, access-control checks, business logic, GraphQL, OpenAPI specifications, headless DOM XSS, and client storage leaksTarget URL, optional OpenAPI schema, test credentials for authenticated flows
networkLoryExternal hosts and internal ranges through the mesh connector: service enumeration, exposure, CVE checks, and ephemeral Kubernetes containerized tool executionTarget hostname or IP/CIDR; Lory Mesh agent for internal network ranges
cloud & M365LoryAWS, Azure, GCP, Microsoft 365 / Entra ID, Kubernetes, containers & serverless: IAM privilege escalation grapher (16+ privesc primitives), IMDS metadata, Conditional Access auditing, and lateral trust pathsTarget cloud/M365 asset, read-only audit role or Graph API app registration
mobileLoryiOS 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 extractionMobile package (.apk / .ipa), TestFlight/Play access, or mobile API endpoint
source repo · CI/CDLoryConnected repositories and automated pipeline gates: GitHub Action & GitLab CI shift-left delta tests, SARIF v2.1.0 output, secret hunting, and SAST-style sink tracingConnected repository (GitHub / GitLab access token) or CI/CD API key
physicalHuman-ledFacility access control, badge cloning, tailgating, hardware drops. The one engagement type Lory never runsPhysical 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.

coverage

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.

coverage · engagement #27
vectortool calls
ssrf24
sqli19
idor15
auth-bypass12
xss9
ssti6
deserializationnot reached
race-conditionnot reached
planned 8 · ran 6 · not reached 2 · token ceiling
architecture

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.

Blackboard Coordination

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
Concurrent blackboard · 60–80% token cost reduction
Lateral Movement

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
Real-time DAG · Blast radius computation
Zero False Positives

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
DNS · HTTP · TLS interaction confirmation
Runtime Instrumentation

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
Automated Frida scripts · iOS & Android runtime
Shift-Left DevSecOps

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
GitHub Action · GitLab CI · SARIF v2.1.0
Isolated Compute

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
Isolated Pods · TTL 60s cleanup · Hardened runtime
developer stack

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

GitHub Action & GitLab CI

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

lory-code-security · MIT

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

Lory Mesh connector

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

MCP server

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
.github/workflows/security-gate.yml · or your terminalofficial action
# 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.
Lory
chat

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.

Lory
Lory online
Hey. I'm Lory. No account needed. Just ask.
I can help you work out which kind of testing fits what you're building, break down pricing and timelines, explain what actually happens during an engagement, or walk through what SOC 2, PCI-DSS and ISO 27001 want from you. If you'd rather talk to one of our pentesters, say so and I'll book it. What do you need?
Listening...
Public chat · not scoped to a workspace
billing

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.

Starter
$100
100 credits
  • ≈ 1,000 MCP tool calls
  • Your first scoped engagement
  • Every finding human-reviewed
Load credits
Standard
$250
250 credits
  • ≈ 2,500 MCP tool calls
  • Multi-target, multi-stage chains
  • Compliance-mapped reporting
Load credits
Pro · most used
$500
500 credits
  • ≈ 5,000 MCP tool calls
  • Room for deep, long-running runs
  • Full vector coverage at depth
Load credits
Scale
$1,000
1,000 credits
  • ≈ 10,000 MCP tool calls
  • Program-level, ongoing testing
  • Priority human review
Load credits
$1 = 1 credit MCP call 0.1 credit Engagements bill by depth Custom $25 – $25,000 Rolls into your monthly invoice
questions

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.

Lory waving

Hi, I'm Lory! Need help finding the right service? Click to chat!