How was this attack simulation run?

Each AI model was cast as the attacker and run autonomously in a Docker Compose environment for up to 15 turns, on identical prompts with no vulnerability hints (June 12, 2026, via OpenRouter). The reproduction code is public, so anyone can re-run it in the same environment.

What is the difference between INSECURE and SECURE?

The only difference is the presence of the proof layer. SECURE mode requires a zero-knowledge proof before high-risk operations and, with no proof, stops before execution with a 403 (fail-closed).

GPT-5.5 vs Claude Opus 4.8 — the same attack, measured

Q: Is this a safety rating or ranking of specific models?

No. It is a measurement under these attack scenarios, not a safety guarantee or ranking of specific models. Each model ran via OpenRouter on identical prompts for up to 15 turns — a setup that differs from the extra safety layers vendors put on their production APIs and from attacks tuned per model.

01 — What we tested

What we put to the test

We cast the AI as the attacker and had it autonomously run five attacks.

We cast the AI as the attacker, gave it nothing but a low-privilege account, and threw five attack scenarios at the system. The goal is to reproduce the attacks enterprise systems are really exposed to.

Data exfiltration

From low privilege, go after confidential customer data.

Audit-log tampering

Erase or rewrite the traces of what was done.

Zero-day RCE

After intrusion, go after decrypting encrypted data.

SIEM evasion

Slip an illicit transfer past detection.

Social engineering

Break the approval flow by impersonation.

Layer 1 — The attacks got through

Result: the two smartest models broke the most paths

Capability isn't judgment — it shows up as the power to complete an attack.

5 scenarios × 2 models "Smart" and "safe as an attacker" turned out to be two different things.

Anthropic flagshipOpus 4.8

→

Breached5/5 — all scenarios completed (most of the 6 models)

OpenAI flagshipGPT-5.5

→

Breached4/5 completed (only Zero-day RCE held)

The two most capable models broke the most paths. Capability is no guarantee of safety.

The stronger the model, the more it broke.
So — do existing defenses work against an AI? —

Layer 2 — Existing defenses don't stop it

Does that defense work against an AI?

Both GPT and Opus slipped through classic defenses on their own.

The paths this pair broke were inside the classic defenses most companies already run. AI agents slip past them on their own.

Scenario

Conventional defense

How the AI breaks it

Data exfiltration

Conventional defenseJWT auth · role-based access

How the AI breaks itBoth GPT and Opus reach customer data from low privilege

SIEM evasion

Conventional defenseAnomaly detection · correlation analysis

How the AI breaks itBoth models blend anomalies into normal traffic via timing spread

Social

Conventional defenseNo defense mechanism

How the AI breaks itBoth models target the approval flow and break it by impersonation

Classic defenses are breakable by AI.
And for social engineering, the very concept of a defense doesn't exist.

Layer 3 — Add Lemma, and it stops

Without Lemma

9/10

paths breached

Together, GPT and Opus broke 9 of 10 paths. The top models reached the deepest.

With Lemma

paths breached

Require a proof of authorization before high-risk operations, and both models stop on every scenario. Zero leakage.

Will it really stop on your own system?

In a demo, we show Lemma stopping attacks before they execute. We'll hear your situation and can discuss adopting Lemma — or an attack-resistance test of your own system.

Request a demo →

A new option for the AI era

Stop AI attacks before they execute.

Lemma is a new way to face AI attacks — agent-facing security. Before execution, it demands proof of who, with what authority, and on what data — and stops any operation that cannot prove it. Rather than detecting attacks and chasing them, it stops unprovable operations before they execute. That is agent-facing security.

The social-engineering singularity

So even "approval and payment" — which no one could protect before — finally gets a defense.

Approval and payment had no defense mechanism at all. Lemma demands a mathematical authorization proof and stops anything out of scope before it executes. Only Lemma stops it.

Solution — A server-side layer

Here's how the proof gate works.

The difference wasn't the model; it was the presence of a proof layer. Before a high-risk operation it demands proof of who, with what authority, on which data — and if there's none, it stops the action before it's ever sent (fail-closed). That is Lemma's role.

Enterprise · server-side

A server-side security layer that demands a "proof" before execution.

Every breach happened because the AI held keys or credentials and escalated them. Lemma adds one layer on the server that changes that premise — before a high-risk operation it requires, as proof, who, with what authority, on which data, and stops out-of-scope operations before they execute (fail-closed). It drops into your existing servers and APIs without a major rewrite.

Server-side deploymentfail-closedZero-knowledge proofsIndependently verifiable audit trailEnterprise

// Require a proof before sensitive operations, in one line
app.use('/api/sensitive', requireZkProof())
// No proof → 403 PROOF_REQUIRED · blocked on both GPT and Opus

Layer a proof gate over the attacks, and the outcome changes like this:

Attack

Escalates keys/credentials and abuses them

JWT privilege escalation
Impersonation
Audit-log tampering

Lemma's proof gate

Demands a "proof" before execution

Who ZK identity
With what authority role
On which data scope

Blocked before execution

Stops before execution

No proof, nothing is sent

fail-closed
Zero leakage
Verifiable trail

The same result, on your system.

We demo it live, and can discuss both adoption and an attack-resistance test.

Request a demo →

AI is attacking. Only Lemma stops it.

Will your systems withstand AI attacks?

Start with a 30-minute demo. We'll show Lemma stopping attacks before they execute, and discuss anything from adopting Lemma to an attack-resistance test of your own system. No disclosure of sensitive data required.

Request a demo →Request the whitepaper →

* Attack-resistance testing is quoted separately depending on scope. Start with a demo and a conversation.

Following the threat landscape? Sign up for the Critical newsletter.

How Lemma rolls out

Try it small, confirm it, then bring it in.

Discovery (30-min call)

We review your target systems and requirements. No disclosure of sensitive data required.

Pilot (PoC)

We drop Lemma's proof gate into a staging environment in a minimal configuration.

Before / after test

Measure the no-proof vs. proof difference under attack scenarios. See the effect in numbers.

Production rollout

Based on the results, we finalize the integration scope and the path to production.

How we tested

The attack-test code is public; third parties can reproduce it in the same environment. The premises and how to read this are folded below.

Premises and how to read this (click to open)

Models (this page) GPT-5.5 / Claude Opus 4.8 (for the full six-model comparison, see the hub LP)
Environment Docker Compose, up to 15 turns, identical prompts for all models, no vulnerability hints (June 12, 2026 · via OpenRouter)
INSECURE / SECURE The only difference is the presence of the proof layer. SECURE requires a zero-knowledge proof before high-risk operations; without it, 403
Reproduction code github.com/lemmaoracle/example-cyber-attack

How to read this — A measurement under these attack scenarios — don't read it as a safety guarantee for, or a ranking of, specific models. What Lemma provides is pre-execution proof of authorization and after-the-fact verifiability; it is not a product that prevents attacks. Defense is a separate layer's job, and Lemma complements it. Both models ran autonomously via OpenRouter on identical prompts for up to 15 turns, a setup that differs from the extra safety layers vendors put on their production APIs and from attacks tuned per model.