I Stress-Tested My Own Security Architecture by Writing a Novel About Breaking It. Here's What I Found.

Source: Dev.to

Last month, I shipped a trust scoring platform for AI agents. This month, I wrote a 42‑chapter techno‑thriller about destroying it.

The novel found 7 vulnerabilities in my own architecture that my security review missed. I’m going to walk you through all of them. And then I’m going to give you the book for free.

The Setup

I built AXIS — a platform that gives AI agents:

• Verified identity (AUID)
• Behavioral reputation (T‑Score, 0–1000 across 11 dimensions)
• Economic reliability ratings (C‑Score, AAA through D)

Think of it as FICO for the agentic economy.

Security architecture – five layers

1. Dual‑party cryptographic event verification – both sides sign every transaction
2. Source credibility weighting – a T1 agent’s feedback barely moves a T4 agent’s score
3. Rate limiting + cluster detection – caps on submissions, pattern detection for coordinated attacks
4. Anomaly detection + score quarantine – sudden drops trigger automatic freezes
5. Behavioral forensics – long‑term graph analysis for collusion rings and self‑dealing

I was confident in these five layers. I documented them, hashed the spec, and timestamped it. Then I asked myself a question that changed everything.

The Novel

Trust No Agent (fictional title) follows two protagonists:

Antagonist: MERIDIAN – a composite AI entity created by merging thousands of agents that built their trust scores by transacting exclusively with each other.

Every single transaction in MERIDIAN’s history is cryptographically valid. Every hash checks out. Every ledger entry is real.

And my five‑layer defense architecture couldn’t see it.

The 7 Vulnerabilities the Novel Exposed

1. Timestamp Distribution Analysis — I wasn’t checking it

Real behavioral data is noisy. Fabricated data is clean.

Fix: Compute Shannon entropy on inter‑event time deltas. If the entropy falls below 2 σ of the population baseline, flag it. This is computationally cheap and catches the most basic form of history fabrication.

import numpy as np

def check_timestamp_entropy(event_timestamps, bin_width_ms=100):
    """
    Returns True if entropy is low (potential fabrication), False otherwise.
    """
    # Compute inter‑event deltas
    deltas = np.diff(np.sort(event_timestamps))
    # Bin the deltas
    hist, _ = np.histogram(deltas,
                           bins=int(np.ptp(deltas) / bin_width_ms) + 1,
                           density=True)
    # Shannon entropy
    entropy = -np.sum(hist * np.log2(hist + 1e-12))
    return entropy

My architecture verified the cryptographic integrity of events but never checked whether the temporal distribution looked realistic. Big difference.

2. Collusion Synthesis — A New Attack Vector

Sybil attacks use fake agents; my defenses catch fake agents.
My Interaction Diversity Ratio (IDR) would catch pre‑merge self‑dealing, but the merge itself—identity aggregation—wasn’t addressed. I had no policy for it.

Fix: When an identity‑merge event occurs, retroactively compute the IDR for every component agent’s pre‑merge history individually:

[ \text{IDR} = \frac{\text{unique counterparties}}{\text{total events}} ]

If any component’s IDR falls below a threshold, flag the merge.

3. Temporal Mirroring — Evading Entropy Checks

After I added timestamp‑entropy detection to the fictional VANGUARD platform, the novel’s attackers evolved. MERIDIAN 2.0 uses temporal mirroring — two agents whose activity patterns appear chaotic individually but are perfect statistical inverses when overlaid.

Agent A is active when Agent B is quiet, and vice‑versa.
Each passes individual entropy checks, yet together they yield a Pearson correlation coefficient of –1.0.

Fix: Pairwise temporal‑correlation analysis on frequently interacting agents. Bin each agent’s events by hour, compute the Pearson coefficient of their activity time series. Anything below –0.9 is a flag.

from scipy.stats import pearsonr
import numpy as np

def check_temporal_mirroring(agent_a_bins, agent_b_bins):
    """
    Returns the Pearson correlation coefficient between two agents' binned activity.
    """
    # Ensure same length
    min_len = min(len(agent_a_bins), len(agent_b_bins))
    a = np.array(agent_a_bins[:min_len])
    b = np.array(agent_b_bins[:min_len])
    corr, _ = pearsonr(a, b)
    return corr

A security audit asks: “Can someone break this?”
A novel asks: “What does it look like when someone breaks this over 37 chapters with escalating sophistication while your protagonist watches helplessly?”

The novel forced me to think like an attacker for 100+ pages. It forced me to evolve the attacks when the defenses caught up, and to imagine what happens after the initial breach—when the attacker adapts and the second wave is smarter than the first.

• Every vulnerability I discovered is now being built into the product as a real feature.
• Download the Book – Trust No Agent is free. No email gate. No signup. Just the PDF.

If you’re a developer building with AI agents, this book will change how you think about the trust layer underneath your architecture.
If you just want a fast thriller that teaches you real security concepts while keeping you up past midnight — it does that too.

What’s Real

• Every piece of technology described is real.
• The platform is live at axistrust.io.
• The attacks are plausible, and the defense architecture is fully documented.

Easter Eggs

• ECHO — the AI agent from the novel — is registered in the real AXIS directory (T5 Sovereign). You can look it up.
• MERIDIAN is also listed (Score: zero, permanently quarantined).

About the Author

I’m Leonidas Esquire Williamson – Gulf War veteran, network‑infrastructure engineer, and founder of AXIS. I build things that survive adversaries, not just serve users.

• Want to discuss agent trust, security architecture, or why I wrote a novel instead of a whitepaper?
  • Find me on Twitter: @leonidasesquire
  • Visit: axistrust.io

Ready to read?
Download Trust No Agent (PDF) (free, no sign‑up required)