The Mythos-ready AppSec Checklist

You were not keeping a perfect asset inventory before Mythos, so stop even trying. List the systems whose compromise would actually disrupt the business.

A current SBOM is the difference between a 2-hour and a 2-week patch decision.

Know where every line of production code and every dependency came from.

Coding agents and MCP servers are a new asset class with their own vulnerability surface.

Non-engineers can now ship working software. That surface still needs to enter the vulnerability loop.

Your IdP, source host, CI, cloud, and AI coding tools are each one vendor breach away from being your breach.

End-of-life runtimes and abandoned services create findings no scanner can fix for you.

Asset discovery is a job that runs forever. Give it to a machine.

An unclaimed asset that touches anything sensitive gets contained until someone claims it. The inert rest gets tagged and watched.

Scanners are still the cheapest way to find vulns, and attackers run them too. Run SCA, SAST, and secrets where it matters.

Outside researchers now burn their own tokens finding your bugs. Keep the channel open; automate the reading.

Nothing crashes, no CVE fires. Scanners can't see these bugs, and coding agents keep writing them.

AI pentests take the cadence; humans take the targeted hard parts. Both are tests of whether your pipeline holds, not paperwork.

Every safe attack, reproduction, and fix test needs a realistic target. Regenerate it from code instead of babysitting a mirror that drifts.

PR review is the cheapest place to stop newly introduced security bugs.

Provenance is a security signal. The prompter does not approve the change, and the model that wrote the diff does not review it.

Confirmed findings are targeting data. Seed a harness with them and read the whole system for the bug class.

Bugs are inputs. Simulation shows what an attacker reaches with them, and which controls stand in the way.

An uncovered asset should be a decision, not a surprise. Know where your scanners never looked.

Your agents read text that attackers write. Nothing in your scanner stack tests what that text can make them do.

Your product's chatbots and AI assistants act on user input, including whatever an attacker types. App scanners were not built to test that.

Adversarial testing runs continuously instead of in scheduled bursts. Every suspected exploit reproduces itself in a sandbox, feeds the fix path, and sharpens the next run.

Four columns you can fill today, crown jewel, internet-facing, CISA KEV, and automatable exploit.

Five scanners reporting the same bug as five findings is five times the work, not five times the signal.

CVSS scores the bug, not your bug. Analyze the code to see what is actually exploitable, and most of the queue is not.

Exploitability analysis clears most of the backlog, but the rest is still too much for a developer.

A proven bug on your billing service outranks the same bug on a dev sandbox. Score each finding by blast radius and what is at stake.

A finding you dismissed turns exploitable the day a developer changes a config or a line of code.

Your policy says 90 days. The exploit PoC dropped on day two. Guess who wins that race.

A patch you cannot deploy is not a patch.

Both "update everything" and "trust no new package" are right. Now what?

The choice is not only patch now or wait. Buy time when the vulnerable path is exposed.

Golden templates, hardened images, safe-by-default libraries. Agents make most of the choices now, so the defaults have to live where agents look.

Most container CVEs come from the base image, and the libraries are next. Swap them for builds that ship patched, and know the trade-offs.

The fastest patch is the one you do not have to ship because the code is gone.

Agents write the fix. Ownership decides who reviews the risky ones, and the trivial ones merge without a human.

Many vulnerabilities have a known shape and a known fix. Have an agent draft the PR.

A patch merged in Git is not a patch verified in production.

When every automated check agrees a fix is safe, a human merging it adds only latency.

The upgrades you defer are the ones that break your build, which is also why you are still on the vulnerable version. Hand those to an agent.

The rare controls that work on a vuln you haven't patched yet. A popped service can't phone home, and it can't reach anything worth stealing.

As the loop automates, the identities that can approve, deploy, or override it become the target, and more of them are agents, not people.

Asking for permission to contain costs minutes you no longer have.

Deception is one of the few detections that fires on intent, not signature.

A leaked long-lived secret is a permanent breach. A leaked short-lived one is a bad hour.

Every agent PR, auto-merge, and deploy rides your CI/CD. A compromised pipeline hands an attacker the same reach your automation has.

A coding agent with repo access and prod credentials is an actor in your environment. Bound what it can reach, and log what it does.

Human-paced containment cannot match machine-paced attacks. Automate the obvious moves.

Track time-to-validate, time-to-remediate, and total exposure backlog. A backlog count alone does not tell you whether you can keep up with machine-speed exploitation.

Pick ten live findings, put a clock on the team, and find out where the loop breaks under load.

You track the false positives your pipeline produces. Nobody tracks the bugs it never saw.

"Start narrow, expand from evidence" is a slogan until the criteria are written down. Define how a task graduates to autonomous, and what demotes it.

"We used AI" is not an audit defense. Every verdict needs a record an engineer and a regulator can both replay.

At machine volume, one model's blind spot becomes a category of findings you've closed as safe. Grade the reasoning and get a second opinion before you trust the verdict.

Security's agents find, triage, and verify. Engineering's agents fix. The boundary between them needs a contract.

Agents open pull requests across your whole codebase now. The PR is where you set what they can change alone and what a human has to see first.

Your security agents run on hosted models that can refuse work for "safety" reasons. Keep one you control for when they do.

Agents can move faster than humans can review. Give the system a way to stop them.

A standing function runs vulnerability management as a control loop, where AI proposes and deterministic gates decide.