Searchlight
An autonomous SEO/AEO agent that works like an employee — it watches the site, fixes what it finds, and verifies its own work before anything ships.
Searchlight is a five-role agent system MnT built on the Claude Agent SDK and pointed at its own site, mntfuture.com. A deterministic Monitor crawls every page; an LLM Analyst judges quality and AI-citability; an LLM Fixer edits the actual source code; a deterministic Verifier blocks anything that breaks the build; an opt-in Shipper commits and deploys. In its first AI-driven fix pass (July 2026), open on-page issues fell from 20 to 6.
An employee, not an audit.
SEO and AEO decay silently: every deploy can push a title over 60 characters, drop a meta description, or break structured data — and nobody notices until traffic dips. Audits are periodic; the web is not. We wanted an employee, not an audit: an agent that re-checks the live site on every run, fixes the source (not the symptom), and never ships a change that breaks the build. The hard problem isn't detection — it's letting an LLM edit production code safely.
A senior-led path from idea to live.
Split judgment from mechanics
Rule-decidable checks (title length, missing meta, broken links, schema presence) stay deterministic code — free, instant, repeatable. Only judgment calls (is this title compelling? will an AI cite this?) go to an LLM.
Give the Fixer real knowledge
A Claude Agent SDK agent reads the repo like a developer — plus a site playbook (voice, keywords, where metadata lives) and persistent memory of past outcomes, so it never repeats a failed fix.
Gate every edit with a build
After each fix, the Verifier runs the typecheck and production build. Failures feed the compiler output back to the Fixer — the self-heal loop — and escalate to a human after N retries.
Dogfood on our own site
We pointed Searchlight at mntfuture.com, measured before and after with its own Monitor, and shipped the fixes through our normal CI to production.
What happened when we pointed it at our own site?
In July 2026, Searchlight's Monitor found 20 open on-page SEO/AEO issues across mntfuture.com. After the first AI-driven fix pass — every change human-reviewed and shipped through normal CI — the same Monitor measured 6 remaining, a 70% reduction. The longest meta description tightened from 197 to 150 characters and the longest title from 72 to 58.
A detection layer and an action layer.
The detection layer
- Deterministic Monitor — crawls the sitemap, checks titles, metas, H1s, canonicals, JSON-LD schema, alt text and broken links
- LLM Analyst (opt-in) — judges title/meta quality, thin content and AEO readiness against the site playbook
- Issues ranked by severity and routed by tier: auto-fix, verify-gated, or escalate to a human
- Every run recorded — issue counts, fixes, escalations — feeding an HTML control-room dashboard
The action layer
- LLM Fixer (Claude Agent SDK) — edits the real source: metadata, schema, alt text, links
- Site playbook + cross-run memory keep fixes on-brand and stop repeated failures
- Deterministic Verifier — typecheck + production build gate with a self-heal retry loop
- Opt-in Shipper — stages only the Fixer's changed files, commits, and pushes to trigger deploy
- Hard guardrails — a neverTouch list (admin, database, env) the Fixer cannot edit
What we shipped, on screen.
Control-room dashboard
Every agent's model, tools and system prompt — plus run history: issues found, fixes, escalations, ships.
The self-heal loop
Monitor → Fixer → Verifier. A failed build feeds the error back to the Fixer; after N retries it escalates to a human.
Persistent memory
Outcomes recorded across runs — fixed, escalated, wontfix — so the agent never repeats a failed or rejected fix.
Where the hard problems were.
Autonomy is easy; safe autonomy is the product. These are the decisions that make it trustworthy.
Build-gated autonomy
No fix ships unless the typecheck and production build pass. The gate is a compiler, not another LLM — objective and non-negotiable.
Self-heal loop
A failing fix gets the build error fed back and retried; unresolved issues escalate to a human with full context after N attempts.
LLM only where judgment lives
Detection mechanics, verification and git are deterministic code. Claude is spent on the two places expertise matters: judging quality and writing fixes.
Persistent memory
Fixed, escalated and wontfix outcomes persist across runs — human decisions are respected, failed approaches aren't repeated.
Site playbook
A per-site Markdown brief — positioning, voice, keyword strategy, and a map of where metadata lives — keeps every fix on-brand and in the right file.
Config-portable
One JSON config per project: site URL, thresholds, fix tiers, playbook, neverTouch globs. The same agent runs against any repo.
Why we chose each piece — and what it buys the agent.
Every technology earned its place by solving a specific problem better than the alternatives.
Claude Agent SDK (claude-opus-4-8)
Used for: The Fixer — an autonomous agent with Read/Edit/Grep/Bash tools scoped to the repo.
Advantage: It works like a developer: finds where a title is defined, edits the source, runs the typecheck — full-auto, inside hard tool and path guardrails.
Deterministic crawler (native fetch)
Used for: The Monitor — sitemap crawl, HTML parsing, link checks on every run.
Advantage: Detection costs nothing, runs anywhere, and returns identical results for identical input — no API key needed just to know the site's state.
tsc + production build as the Verifier
Used for: The regression gate every fix must pass before it counts.
Advantage: An objective, binary judge. An LLM never decides whether the build passed — the compiler does.
Git-based Shipper (opt-in)
Used for: Stages only Fixer-changed files, commits with an audit trail, pushes to the deploy branch.
Advantage: Ships ride the existing CI/CD path with human-readable history — and it's off by default.
JSON memory, tracked in git
Used for: Cross-run outcomes: fixed, escalated, wontfix — committed alongside fixes.
Advantage: Each run is a fresh process, so memory lives in the repo — it survives thrown-away CI machines and the git log doubles as an audit trail.
Opt-in LLM Analyst
Used for: Quality and AEO judgment — weak titles, generic metas, AI-citability — on top of the free deterministic pass.
Advantage: The expensive model runs only when asked (--deep), capped per run, and judges against the playbook so verdicts are on-strategy.
What it's built on.
- Claude Agent SDK
- claude-opus-4-8
- System-prompt registry
- TypeScript
- Node 20
- Zero runtime deps (core)
- tsc + build gate
- neverTouch globs
- Tiered auto/verify/escalate
- Git + GitHub
- DigitalOcean CI
- HTML dashboard
The questions buyers ask about this build.
Every fix must pass a deterministic gate — the TypeScript typecheck and the production build — before it counts. If the gate fails, the compiler output is fed back to the Fixer to correct (the self-heal loop); after N failed retries the issue escalates to a human. A change that breaks the build structurally cannot ship.
Judgment uses Claude: the Analyst (is this title compelling? will an AI engine cite this page?) and the Fixer (write the actual code change). Everything rule-decidable is deterministic code: crawling, length/presence checks, link status, the build gate, and git. That split keeps runs cheap, repeatable, and safe — an LLM never grades its own work.
Yes — and the numbers are from its own Monitor, measured before and after. In July 2026 the first AI-driven fix pass cut open on-page issues from 20 to 6: metas over 155 characters rewritten (longest 197 → 150), titles over 60 trimmed (72 → 58), with every change reviewed and deployed through normal CI.
Only if you turn that on. The Shipper is opt-in and off by default: when enabled, it stages only the files the Fixer changed, commits with an audit message, and pushes to the deploy branch — and it never ships anything the Verifier hasn't passed.
Yes — it's config-driven by design: one JSON file sets the site URL, thresholds, fix tiers, brand voice, playbook and neverTouch paths. This is the engine behind MnT's Embedded AI Agents service — the same pattern, domain-trained for your stack.
Want an agent like this embedded in your stack?
Searchlight is the pattern behind our Embedded AI Agents service — domain-trained agents with hard safety gates. Book a free agent-readiness audit and we'll map where one pays off in your commerce stack.