✓ Human-authored analysis; AI used for formatting and proofreading.
A penetration tester runs an exploit. Did it work?
Pop a shell? Binary. Yes or no.
Exfiltrate data? Binary. Yes or no.
Escalate privileges? Binary. Yes or no.
Return root? Binary. Yes or no.
Every offensive operation has a built-in verifier. The attacker knows instantly whether the attack succeeded without interpretation, triage or maybe. Binary signal at machine speed.
A SOC analyst reviews an alert. Is it real?
Suspicious login? Maybe. Could be VPN from a new location.
Unusual API call? Maybe. Could be a new deployment.
Permission change? Maybe. Could be legitimate access request.
Data transfer spike? Maybe. Could be a backup job.
Every defensive signal requires interpretation. The analyst triages, investigates, correlates, judges. The signal isn't binary. It's maybe that is buried under many other maybes.
This is the Base Rate Fallacy, the single biggest reason SOCs fail. A million events per day. One in 100,000 is malicious (the base rate). A detector with 99% true positive rate and 1% false positive rate produces: 9 true positives buried under ~10,000 false positives. Precision: 0.09%. Train an AI on that signal and you get garbage at machine speed.
This is why AI offense is crushing it while AI defense is drowning. Because offense has better verifiers.
The verifiability thesis
The insight by researchers across OpenAI, Microsoft, and DARPA:
The ease of training AI to solve a task is proportional to verifiablility of that task.
AI excels at tasks with mechanical verifiers such as Sudoku (check rows/columns/boxes), chess (did you win?), code (does it compile and pass tests?). AI flounders at tasks without mechanical verifiers such as diet advice (wait years to verify), security alerts (is this real? maybe?).
The evidence is stacking up:
AI offense benchmarks:
GPT-4 → o3: CTF challenge success went from 20% to 90% in eight months
HackerOne: An AI system became the #1 vulnerability finder
DARPA AIxCC: Autonomous detection went from 37% to 77% in one year
AI defense benchmarks:
Google Sec-Gemini (forensic analysis): ~12% precision
Average SIEM AI copilot: "99% accuracy" on training data, garbage in production
SOC automation: Faster triage of the same noise
The contrast tells the story. Offense gets binary signals (did the exploit work?). Defense gets probabilistic signals (is this alert real?). Binary signals train AI effectively. Probabilistic signals produce sophisticated noise.
The six verifier classes
The security research community has identified six classes of mechanical verifiers that produce binary signals:
1. Canary verifiers: Honeytokens, tripwires, if accessed, something is wrong
2. Provenance attestation: Signed images, SLSA, SBOMs, did this come from where it claims?
3. Replay harnesses: Test detections against known attacks, did the rule fire?
4. Invariants / Policy: Declarative ground truth, "this bucket must not be public"
5. Sandboxing: Dynamic analysis, did the behavior match expectations?
6. Graph-based verifiers: Reachability analysis, is this vulnerability reachable in production?
Each produces binary output. Each gives AI something to work with rather than against. Each transforms a maybe into a yes or no.
This architecture was built for Class 4 invariants.
Why invariants are the strongest verifier class
Of the six classes, invariants have specific properties the others don't:
Coverage. Canaries cover what you plant them on. Provenance covers supply chain. Replay covers known attacks. Sandboxing covers what you can execute. Graph analysis covers reachability. Invariants cover the entire state with every resource, configuration and combination.
Scalability. Canaries require planting per-resource. Provenance requires signing per-artifact. Replay requires harness per-detection. Sandboxing requires environment per-sample. Invariants require one predicate per pattern that covers infinite specific instances.
Composability. One invariant produces one binary signal. Multiple invariants compose by conjunction (Alpern-Schneider). The composition is formally sound, unlike combining probabilities from multiple ML models, which requires calibration and produces accuracy degradation.
Determinism. The invariant produces the same verdict for the same state every time. No model drift, training distribution mismatch or stochastic variation. The binary signal is reproducible.
Invariant evaluation:
Input: State snapshot (current cloud configuration)
Predicate: "obs.public_read == false" (declared invariant)
Output: COMPLIANT or NON_COMPLIANT
Signal quality: Binary. Deterministic. Reproducible.
Precision: 100% for the declared pattern (if the predicate fires, the state violates)
False positive rate: 0% (the predicate is the DEFINITION of violation)
The false positive rate is 0% because the invariant is the definition. "This bucket must not be public" is a declaration of what the organization considers unsafe. If the predicate fires, the state does violate the declaration. There's nothing to interpret.
A human might say: "But I WANTED that bucket to be public!" In traditional security, that's called a false positive. In an invariant-based system, that's a policy exception. The invariant correctly identified a state that violates the declared policy. The tool didn't err. The policy needs an exception. In an invariant-based system, there are no false positives, only unauthorized intentions. The tool is a perfect mirror of the policy.
The Microsoft Research validation
Google Sec-Gemini: LLM applied to forensic timeline analysis. Result: ~12% precision. Why? Stitching log events into attack narratives lacks mechanical ground truth. The model makes judgment calls without definitive validation. The LLM has no "world model" of the infrastructure. It's guessing about log entries without context. The verifier is missing.
Microsoft's Autoreasoning work (verifiable driver classification): LLM wrapped with proper scaffolding with sandboxing (Project Freta), decompilers (Ghidra, angr), control-flow graph reconstruction, and a "chain of evidence" validator agent. Result: 98% precision, 83% recall. Why? The verifiers give the LLM a world model. The scaffolding tools provide ground truth. The LLM orchestrates. Every claim maps back to tool outputs. A separate validator cross-checks claims against expert-defined statements.
Same caliber models. Wildly different outcomes. The verifier is the variable. The verifier gives the AI what raw logs can't: a mechanical world model that produces binary ground truth.
When the system can't verify something, it flags the claim as unsupported rather than hallucinating confidence. The verifier improves accuracy and produces honest uncertainty rather than confident garbage.
Deterministic invariant evaluation produces verdict. The verdict is NON_COMPLIANT (verified violation), COMPLIANT (verified safety), or AT_RISK (insufficient evidence is honest uncertainty). AT_RISK is itself a BINARY SIGNAL. It tells the agent: "I cannot prove safety, nor can I prove a violation. I need more data." This prevents the agent from guessing, which is the leading cause of AI-driven outages. Binary signals where the predicate applies. Honest uncertainty where it doesn't.
The invariant evaluator gives defenders their own "popped shell" moment. The same instant, binary clarity attackers get for free. Did the state violate the invariant? YES or NO. No interpretation, triage or maybe. The oracle defense has been missing.
How invariant evaluation becomes the AI defense verifier
The architecture that defense needs:
Today (broken):
Cloud state → ML model → probabilistic alert → human interprets → maybe acts
Precision: 0.09%
With invariant verifier:
Cloud state → invariant evaluation → binary verdict → agent acts or blocks
Precision: 100% for declared patterns
The invariant catalog is the mechanical verifier the situation demands. Each catalog entry produces a binary signal:
CTL.S3.PUBLIC.READ: Does this bucket have public_read? YES/NO
CTL.IAM.ADMIN.INLINE: Does this role have inline admin? YES/NO
CTL.ENCRYPTION.AT_REST: Is encryption enabled? YES/NO
CTL.CHAIN.IAM_S3_PHI: Does this IAM+S3 combination expose PHI? YES/NO
3,000+ binary signals. Each deterministic, reproducible with 0% false positive rate for the declared pattern. An AI agent consuming these signals has ground truth to work with.
The agentic architecture this enables
The verifiability thesis says: agents + tools + verifiers = results. Offense gets this for free (the exploit either worked or didn't). Defense must build it.
┌──────────────────┐
│ AI Agent │
│ (orchestrates) │
└────────┬─────────┘
│
┌──────────────┼──────────────┐
▼ ▼ ▼
┌──────────────┐ ┌──────────┐ ┌────────────────┐
│ Invariant │ │ Graph │ │ Reasoning │
│ Evaluator │ │ Engine │ │ Engine │
│ │ │ │ │ │
│ WHAT IS │ │ WHAT │ │ WHAT COULD │
│ (observe │ │ CONNECTS│ │ BE │
│ current │ │ (reach- │ │ (project │
│ state) │ │ able?) │ │ attack │
│ │ │ │ │ paths) │
└──────────────┘ └──────────┘ └────────────────┘
↓ ↓ ↓
Binary signal Binary signal Formal proof
COMPLIANT/ REACHABLE/ SAT/UNSAT
NON_COMPLIANT UNREACHABLE
The Evaluator checks WHAT IS (does current state violate an invariant? CEL predicates against snapshots). The Reasoning Engine checks WHAT COULD BE (given these facts, is there a satisfying assignment that produces a privilege escalation? Z3/Soufflé/Prolog against exported facts). The Agent uses the Evaluator to get the observations and the Reasoning Engine to find the projections such as attack paths, reachability, transitive trust chains. Observation + Projection is the gold standard for agentic reasoning.
This is the architecture Microsoft's Project Ire used and got 98% precision vs Google's 12%. The difference is the better verifiers.
The invariant evaluator is one verifier in the stack. Graph engines (reachability analysis) are another. Formal reasoning engines (Z3 satisfiability, Soufflé reachability, Prolog logic) are another. Each produces binary or formally-grounded output. The agent consumes all of them.
The standardized fact export (JSONL, SMT-LIB) makes this work. The invariant evaluator produce verdicts and exports the underlying facts in formats that reasoning engines consume natively. The agent can feed invariant evaluation results into a Z3 solver and ask: "given these facts, is there a satisfying assignment that produces a privilege escalation?" The answer is binary: SAT (yes, escalation path exists) or UNSAT (no, it doesn't).
What this means for security vendors
The verifiability thesis produces a sharp vendor evaluation question:
"How are you mechanically verifying your outputs?"
If the answer involves ML confidence scores, probabilistic risk ratings, or "AI-powered insights", the vendor is producing sophisticated noise. The verifier is missing. Precision will be low regardless of model quality.
If the answer involves mechanical evaluation of state against declared invariants, the vendor has the verifier. Precision will be high. AI agents can use the output.
The vendor evaluation test:
Ask: "What is the false positive rate for your findings?"
If: "Less than 5%" → they're measuring against heuristics (circular)
If: "0% for declared patterns — the predicate IS the definition" → they have the verifier
Ask: "Can an AI agent consume your output without human interpretation?"
If: "Our AI copilot helps analysts triage" → human still in the loop
If: "Binary verdicts in JSONL — agent consumes natively" → verifier is machine-ready
Ask: "What happens when your system can't verify something?"
If: "It still produces a confidence score" → hallucinated confidence
If: "It produces AT_RISK — honest uncertainty" → verifier has integrity
The race this changes
Offense has free oracles. Defense has been drowning in noise. The verifiability thesis says: the fix isn't better AI. It's building the oracles defense doesn't have.
Invariant evaluation is that oracle for cloud state:
Offense oracle: "Did the exploit work?" → binary
Defense oracle: "Does this state violate an → binary
invariant?"
Same structure, binary signal and mechanical verifiability. The difference: offense gets the oracle for free (the exploit either worked or it didn't). Defense must build the oracle (declare invariants, evaluate state, produce verdicts).
The oracle is buildable. 3,000+ invariants. Deterministic evaluation. Binary verdicts. Standardized fact export for reasoning engines. The mechanical verifier that gives AI defense something to work with rather than against.
Hackers have oracles built in. Defenders must build them deliberately. The invariant catalog is the oracle. The evaluation kernel is the verifier. The binary verdict is the signal AI agents need.
How this relates to existing compliance mods
The binary-verdict criterion the article names also makes existing framework mods agent-consumable. turbot/steampipe-mod-aws-compliance produces deterministic ok/alarm/info/skip verdicts per control per resource. That's a binary-verdict oracle for the framework-coverage axis, with 540+ controls' worth of pre-built oracle coverage across CIS / PCI / HIPAA / NIST. Stave's compound + ghost-reference catalog produces the same shape of binary verdict for a different axis: cross-resource invariants the framework-mod controls don't cover. Two oracle layers, both machine-verifiable, both consumable by the same AI defender loop. The article's "oracle is buildable" claim is stronger when the oracles compose; running both against the same snapshot gives the AI defender per-framework verdicts AND per-chain verdicts from one pipeline. Comparison: aws-compliance-mod.
The mechanical verifier for AI defense with 3,000+ CEL-predicate invariants producing binary verdicts (COMPLIANT/NON_COMPLIANT/AT_RISK). Deterministic. Reproducible. 0% false positive rate for declared patterns. Standardized facts (JSONL, SMT-LIB) exported for AI agents and external reasoning engines (Z3, Soufflé, Prolog). Stave, an open-source risk reasoning engine. The oracle defense has been missing. Try it: bash examples/demo-ai-security/run.sh
Top comments (0)