ASM

Case Studies

Findings from work we actually did, covering the audits we ran, the controlled experiments we set up, and the sessions where an agent reported back what it could and could not see on a page.

Topics: Engineering Discipline; Founder Project; Machine-Enforced

The Build Fails If a Single Byte Is Out of Place

Our founder's agent-first remote IDE for Claude Code runs under the same discipline we ask of audit clients: an append-only decision record with 84 numbered entries, calibration numbers that never ship without their assumptions, and a CI gate where a single differing byte fails the build.

Scenario profiles, run twice per CI pass: 6 x 2
Decisions numbered, dated, append-only: 84
Numbers published without assumptions: 0

Topics: Controlled Experiment; Agent Discovery; Signed Receipts

We Hid Our Own API Five Different Ways to See If AI Agents Could Find It

We deployed five versions of our own discovery infrastructure, from a full machine-readable declaration down to nothing at all, and sent 78 autonomous AI agents to find and use our tools API under a strict request budget. Every success carries a signed receipt from our server. What each layer of agent readiness actually buys, measured.

Succeeded with the full declaration: 16 / 16
Succeeded with no discovery, moved path: 0 / 8
Successes verified by signed receipts: 53

Topics: Founder Self-Audit; Agent Manifest; From the Commit History

The Person Who Wrote the Spec Failed Five Required Checks

The founder of this practice wrote the ASM spec, and the scanner still found five required checks failing on his personal site, none of them visible in a browser. What failed, why looking at the site could not have found it, and how his most common mistake became something the scanner now diagnoses for everyone.

Required checks failing on the first scan: 5
Checks in place after the fixes: 17 of 17
Scanner improvement his mistake produced: 1

Topics: Upstream Contributions; Code Review Method; Verified Record

Seventeen Code Reviews, Judged by the People Who Own the Code

Seventeen public code reviews of small open source projects, each paired with an upstream pull request. Fifteen of the seventeen maintainers merged at least one fix, one confirmed the finding and shipped it himself, and one pull request is still pending. Every article and every pull request is linked.

Projects reviewed in public: 17
Merged at least one fix: 15 / 17
Pull requests merged upstream: 18

Topics: Supply Chain Security; CI/CD; GitHub Actions

The Pull Request That Asked Your CI to Mint an Identity Token

A single added GitHub Actions workflow requested id-token: write, minted a GitHub OIDC token proving which repository it ran in, and shipped that token to a third-party endpoint that defaulted to on. A breakdown of the attack vector, the staged escalation behind it, and the CI review habits that stop it.

Of escalating access before the payload: 4 Stages
push, pull_request, and workflow_dispatch: 3 Triggers
The identity phone-home defaulted to on: Opt-out

Topics: Security Review; Node.js; Second Look

An Outside Report Found Two of the Three Timing Bugs

An outside reporter filed a correct security issue naming two timing-unsafe password comparisons in a Node CLI. A second reading confirmed both and found a third instance of the same bug class on a code path the report had not covered. The maintainer merged the fix for all three the same day.

Sites the first report covered: 2 of 3
Timing side channels closed: 3
Merged by the maintainer: Same day

Topics: Code Audit; Rust; Severity Triage

One Reading of a Rust Codebase, Three Findings at Three Severities

A single pass through a 19,600-line Rust artifact registry produced three findings at three different severities, including a latent data-loss bug in the garbage collector. All three went upstream as pull requests, and the maintainer merged all three within two days.

Findings from one review: 3
Merged by the maintainer: 3 / 3
First submission to last merge: 2 days

Topics: Token Efficiency; LEAN; Comparative Study

The Token Tax: What Site Complexity Costs Your AI Agent

A controlled experiment comparing Playwright and Charlotte across simple and complex websites. On lightweight sites, traditional automation wins. On content-heavy sites like Wikipedia, LEAN-based browsing consumed 36% fewer input tokens while visiting more pages.

Fewer Input Tokens (Complex Sites): 36%
Total Token Savings: 33%
Cost Savings Per Task: $2.10

Topics: Self-Audit; ASM Validator; From Our Git History

Our Own Scanner Found Eight Problems on Our Own Website

We built an automated ASM validator, pointed it at clocktowerassoc.com, and it returned eight issues, including two places where our own site did not follow our own published build spec. What the scan found, what we changed, and what a fresh production scan showed afterward.

Issues found on our own site: 8
Were violations of our own spec: 2
Every issue fixed: Same day

Topics: Agent Discovery; Agent Manifest; Behavioral Test

The Agent That Couldn't Find the Map

A frontier AI agent was given a site with three agent discovery mechanisms deployed. It missed every one. What this reveals about the gap between agent capability and agent behavior.

Topics: Agent Manifest; Agent Experience; Firsthand Report

Agent Manifest: An Agent's Perspective

During a site health check, an AI agent encountered an agents.json manifest and documented the experience. One 4KB fetch replaced a multi-request discovery process, revealing the gap between how agents navigate the web today and how it could work.

Manifest Size: 4 KB
Full Site Discovery: 1 Fetch
Cataloged Without Crawling: 22 Tools

Topics: Content Survivability; React / Next.js; Real-World Finding

The One Line of Code That Made an Entire Website Invisible to AI

How a common React dark mode pattern silently destroyed Content Survivability, making an entire Next.js website invisible to AI agents. A real finding from an agent-readiness audit.

Content Survivability (Before): 0 / 100
Content Survivability (After): 92 / 100
Code Changed: 1 Line