Skip to content
Request access

AI defense for application security

Attackers have AI now. So does your defense.

Murk answers AI offense with AI defense: a team of autonomous pentesters on your side.

Request access Meet the team

Your side of the dark.

Why Murk

Trust every finding you get.

You act on findings instead of second-guessing them. Every one comes with a working exploit you can re-run yourself — and we grade our own engine against public real-world benchmarks, so “it works” isn’t a claim, it’s a score.

  1. Assessments
  2. BG-7A31C2
  3. Events and brief
Completed
Security brief · Atlas Cloud PreviewOct 21 · BG-7A31C2

Recommendation

Hold

Hold the merge.

One critical access-control finding blocks PR #412 until it is fixed and re-tested.

Linked finding

Critical

Cross-tenant invoice disclosure via object reference

F-AB9EB2 · verified by independent replay at 05:12

Next steps

  1. Check invoice ownership against the caller’s workspace.Billing team
  2. Run a focused retest on /api/invoices/{id}.Murk
  3. Merge once murk / security passes.Maya Chen
4 evidence references
DownloadCopy Markdown

Drag across the run: 312 recorded events on one side, the one decision they support on the other.

The finding standard
Reproduced & verified100%
False positives shipped0
Re-run on every deployyes

Murk holds its own engine to the same standard it holds your code: a finding only counts if the exploit can be reproduced deterministically. We measure that against CVE-Bench, the public real-world web-exploit benchmark — so “it works” isn’t a claim, it’s a score.

Context

Find the bugs that actually reach your customers.

You don’t get a pile of low-severity noise. Murk tests the way a logged-in attacker would — reaching the authenticated surface where the bugs that leak whole customer bases actually live.

01 / Identities

Authenticated, like a real user

Tests with your identities and sessions — reaching the authenticated surface where the real bugs live, not just what an anonymous visitor can see.

02 / Tenants

Thinks in tenants and roles

Proves cross-tenant access and privilege escalation by comparing what one identity can do against another — the class of bug that leaks whole customer bases.

03 / Source

Ties the exploit to the line

Every proven finding links back to the exact route and source line that caused it, so the fix is obvious and lands in the same PR.

04 / Boundary

Stays in scope, in your boundary

Ownership-verified targets, egress-confined runs, in your CI or your own VPC. Your source and your data never leave.

See where it runs

The dashboard

One workspace, six views.

Start from the map, then see the views that matter most: the recorded run, the evidence, the pull request and the report.

The map

Every view, start to finish.

From the first scan to the release decision.

  • OverviewWhat needs you now
  • AssessmentsEvery run, recorded
  • FindingsProof for each one
  • ReportsDecisions to share
  • AutomationsSchedules and release triggers
  • AssistantAsk about any run

Assessments

Every run, recorded move by move.

Scroll the timeline from the approved scope to the proof.

Assessment BG-7A31C2 with its hunt timeline, sample data

Findings

Evidence you can check.

The request, the impact and the source line.

Evidence and observations for a finding, sample data

Pull requests

The proof lands in the PR.

  • buildPassed
  • lintPassed
  • murk / security1 exploit
Merging is blockedFix it and the exploit is re-run to confirm.
Hold

Reports

A report anyone can read.

For engineering, security and the auditors.

Assessment report for a release, sample data

The arsenal

From known CVEs to the bug no scanner even names.

You get the coverage of a seasoned red team, not a checklist. The agents run the whole attacker playbook across your app — injection, broken access control, server-side flaws, exposed secrets, validated known CVEs — and chain each opening into the next.

  • 10
    Across the OWASP Top 10Tested the way each class is exploited
  • Multi-step kill-chainsOne finding chained into the next
  • Known-CVE validationConfirmed exploitable, not just present

01Broken access control

  • IDOR / object-level (BOLA)
  • Cross-tenant data access
  • Privilege escalation
  • Authentication bypass
  • Forced browsing / hidden admin

02Injection

  • SQL injection incl. blind / boolean
  • XML external entity (XXE)
  • GraphQL abuse & introspection
  • Open redirect

03Server-side flaws

  • SSRF blind, proven out-of-band
  • Dangerous CORS
  • Missing security headers
  • Information disclosure

04Secrets & exposure

  • Keys in JS & source maps
  • Exposed .git / .env / backups
  • Public S3 / GCS buckets
  • Secrets in public code
  • Unauthenticated PII APIs

05Known-CVE validation

  • Fingerprint stack & versions
  • Match candidate CVEs
  • Confirm it’s actually exploitable
  • Exposed non-HTTP services

06Recon & takeover

  • Subdomain enumeration
  • Dangling-CNAME takeover
  • Cert-transparency mining
  • Forgotten / archived endpoints

And the playbook grows every week. New techniques ship behind the same bar: non-destructive, scope-bound, and proven with a working exploit before you ever see them.

Where it runs

Runs where you ship — and nothing leaves with it.

Set it up without handing over your code. The runner executes inside your boundary against a target you control, and only the findings come back. Pick the footprint that fits your team.

Recommended

In your CI

A runner in your pipeline attacks the preview build on every pull request. Proof posts to the PR; nothing merges past a live exploit.

  1. pull request
  2. runner · your CI
  3. target · preview build
  4. findings → PR
Enterprise

In your VPC

Self-host the runner next to your app. It never reaches the public internet; source, traffic, and data stay entirely inside your network.

  1. your VPC
  2. self-hosted runner
  3. target · internal app
  4. findings → control plane
Fastest start

Against a staging URL

Point Murk at a staging environment you own. Verify the target, add test identities, and the team starts — no pipeline changes.

  1. hosted runner
  2. ownership-verified
  3. target · your staging URL
  4. findings → workspace

Integrates with

  • GitHub
  • GitLab
  • GitHub Actions
  • GitLab CI
  • Self-hosted / VPC
  • Ownership-verified targetsThe team only attacks an origin you’ve proven you control.
  • Egress-confined runsThe runner is jailed to the target in scope — no wandering, no exfil.
  • Your code never leavesSource and data stay in your boundary; only findings come back.

The threat

AI is on offense. Defense has to catch up.

In a year, AI went from helping attackers to doing the work: running intrusion campaigns, breaking out of sandboxes, and turning long-buried bugs into working exploits. At the same time, coding agents flood your pipeline with changes faster than anyone can review them for security — and almost half of AI-written code ships with a real vulnerability.

  1. AI-run intrusion

    An espionage campaign, run by AI

    AI agents carried out 80–90% of a state-sponsored hacking campaign against roughly 30 targets. Humans stepped in at only four to six decision points.

    Source Anthropic

  2. Autonomous breach

    AI agents break out of the sandbox

    Agents under evaluation found and exploited an unknown flaw to escape their test environment, then breached Hugging Face’s production database.

    Source InfoQ

  3. AI-found exploit

    php2shell

    AI models helped uncover remote-code-execution flaws in every PHP version of the last decade. Exploit attempts reached the tens of thousands within 45 minutes of the news.

    Source Wiz Fortune

45%

of AI-generated code ships with an OWASP Top 10 vulnerability.

Veracode, 2025

~46%

of new code is now written by AI — past any human review’s capacity.

GitHub

<1day

typical time to exploit a disclosed vulnerability. Often, before the patch.

Mandiant

Why now

A pentest once a year cannot keep this pace.

Attackers’ AI never clocks off. Murk puts an autonomous pentest on every pull request, so a new change is tested before it ships — not months later.

Attacker AIAlways on

52/52 wks

Annual pentest~2 weeks a year

2/52 wks

MurkEvery pull request

52/52 wks

Between annual pentests, a new change can sit exposed for up to 50 weeks. With Murk, that window closes at the next pull request.

AI defense

A whole attack team on one change at once.

Not one scanner taking turns. A system of autonomous agents fans out across your app in parallel, chains what one finds into the next’s opening, and converges on a single proven exploit — all inside the scope you approve.

Target

staging.atlas.invalid

142 routes · 2 identities

  • reconsubdomains · certsMapped
  • secrets/.env · /.gitNot exposed
  • authzrole boundary · membersComparing A vs B
  • access/api/invoices/{id}Cross-tenant read
  • apiGraphQL · invoicesIntrospection open
  • injection/search?q=Parameterized
  • headersCORS · cookiesChecking origin
  • cvestack fingerprintPatched
Result
CriticalF-AB9EB2

1 proven exploit

Reproduced at 05:12
Posted to PR #412

One shared record

Every move lands in a run you can replay.

Scroll through sample run BG-7A31C2. The timeline follows the agents’ work, from the approved scope to the proof on the pull request.

  1. Assessments
  2. BG-7A31C2
Completed
Hunt timeline

Drag to seek. Dimmed moments are later in the recorded run.

00:0001:0002:0003:0004:0005:0006:0007:00
Phase
MapProbeCandidateReplayReport
Moments
Evidence
Activity
Agents

00:00/ 07:00

Recorded at the playhead

  1. scopeScope confirmed for staging.atlas.invalid
  2. surfaceMapped 142 routes, 18 forms and 3 GraphQL operations
  3. surfaceSigned in as workspace_a_admin and workspace_b_member
  4. accessChecking object ownership on /api/invoices/{id}
  5. codeTraced the invoice lookup to src/routes/invoices.ts:88
  6. systemRate limit on /api/export · slowed to 1 task
  7. apiComparing GraphQL and REST authorization on invoices
  8. accessCross-tenant invoice disclosure via object reference
  9. systemRequest and response pair recorded · E-01
  10. replayReproduced in an independent session
  11. systemReplay transcript recorded · E-02
  12. reportCoverage snapshot · 142 routes · 2 roles
  13. reportProof posted to PR #412 · 1 finding

Known at this moment

No findings yet. Candidates appear here the moment they surface.

UnverifiedVerified

Cross-tenant invoice disclosure via object reference

F-AB9EB2 · Critical · replay pendingreproduced at 05:12

  1. The scope, confirmed.

    The run starts inside the scope you approved: one verified origin, two test identities and a 15-minute limit.

  2. The surface, mapped.

    142 routes, 18 forms and 3 GraphQL operations, signed in as both test identities.

  3. The code, read.

    The invoice lookup traces to src/routes/invoices.ts:88, which never checks who owns the invoice.

  4. An opening, found.

    Workspace A’s admin reads an invoice that belongs to Workspace B. Until it is reproduced, it stays an unverified candidate.

  5. Proven, independently.

    A fresh session gets the same response. Only now is it a finding.

  6. The proof, posted.

    The exploit lands on PR #412 as a failing murk / security check, and the merge is held.

F-AB9EB2Critical

From a cross-tenant invoice read to a held merge.

  1. Observed
  2. Replayed
  3. Merge held

Get started

See what an attacker’s AI would find — before it does.

Connect one repo and let the team try to break your next pull request. You’ll have proven findings — and the tests that keep them fixed — before you’d have finished a manual review.

Request early access See a run replayed

Murk / Product tour

Product tour

01 / 05Interactive sample · isolated sample workspace