We Scanned 101 AI Agents. The Average Security Grade? C+.

The C+ Problem

We scanned 101 AI agents from the most popular frameworks. The results should worry you.

Not because the agents are catastrophically broken — they're not. But because the industry average is C+, and that's not good enough. Not when agents have shell access, API keys, and the ability to delegate to sub-agents.

This isn't theoretical. These are production agents. Real deployments. Running on real infrastructure with access to real data.

62% of agents scored a C. Not failing. Not excellent. Just… mediocre. And in security, mediocre is a liability.

🚨 The Trust Scoring Crisis

This is the #1 blind spot in the entire agent ecosystem:

38% of agents fail trust scoring entirely. Only 7% fully pass.

Here's what that means: When an agent delegates to a sub-agent, almost nobody verifies the sub-agent is trustworthy. No reputation checks. No behavioral validation. No attestation chain.

This is how supply chain attacks will happen. An attacker compromises one agent. That agent spawns sub-agents. Those sub-agents inherit capabilities but not constraints. The compromise spreads.

🔐 The Sensitive Data Problem

When your agent has access to API keys, credentials, and PII, proper data masking isn't optional. It's mandatory.

Only 37% of agents fully pass sensitive data masking. Another 52% have partial coverage. 6% outright fail.

Partial coverage means the agent might mask API keys in logs but not in memory dumps. Or mask credit cards but not SSNs. Or mask data at rest but not in transit.

This is a ticking time bomb.

Category Breakdown

We tested 27 security checks across 6 categories. Here's how agents performed in each:

The weakest category? Permissions & Access Control. This is foundational stuff — who can do what, when, and under what conditions. If you don't get this right, nothing else matters.

The strongest category? Supply Chain Integrity. Most frameworks at least attempt dependency verification, package signing, and reproducible builds. Not perfect, but better than the rest.

Notice a pattern? The failures cluster around delegation, trust, and data handling. The exact areas where agents get autonomy.

Framework Comparison

Which frameworks are most secure? We grouped agents by their underlying framework and calculated average scores:

Key findings:

• Big tech frameworks (Anthropic, Microsoft, Google, OpenAI) score highest — but none break into the A range.
• Custom-built agents (84 of 101) average C+. Builders rolling their own security often miss critical checks.
• LangChain, the most popular framework, scores 78.2 (C+) — right at the industry average.
• OpenClaw (our own platform) scores 75.0 (C). We're working on it.

The Best and The Worst

What separates the top 5 most secure agents from the bottom 5?

What This Means

The agent security gap is real and measurable. It's not theoretical. It's not hypothetical. It's documented in 101 real-world agents.

As agents get more autonomy — shell access, API calls, sub-agent delegation, multi-agent collaboration — a C+ security posture isn't good enough.

Here's what worries us most:

• Trust scoring is almost universally broken. 93% of agents don't fully implement it.
• Sub-agent safety is weak. Capabilities propagate, constraints don't.
• Sensitive data handling is inconsistent. Only 37% get it right.
• Custom-built agents have no baseline. 84 of 101 agents are custom — and they average C+.

This isn't an indictment of any single framework or builder. It's a systemic issue. The ecosystem hasn't prioritized security at the architecture level.

The good news? These problems are solvable. The architecture exists. The patents are filed. The tools are being built.

The bad news? Most agents aren't implementing them yet.