How a Fleet of Claude Managed Agents Grew Prepa IN's SEO and AI Visibility 20x
Prepa IN’s blog used to be one more item on a to-do list that never got shorter. We had plenty to write about: Prepa IN is an online high school in Mexico for anyone 18 and over, so there’s a constant stream of real questions and stories. Turning that into consistent, well-optimized content was still a multi-hour manual job per post. Today the whole pipeline runs on a fleet of Claude managed agents, and our SEO and AI visibility is roughly 20x where it started.
This post is the technical version of that story: the architecture, why it’s shaped the way it is, and what breaks.
The system in one picture
There is no long-running process and no server we operate. Anthropic hosts the agent loop and the sandbox; a scheduled deployment fires one session a day, the session runs a full cycle, and then it goes idle. The “control plane” is a set of versioned YAML definitions applied with the Anthropic CLI; the “data plane” is the session itself.
A thin coordinator and a specialized roster
The fleet is a thin coordinator plus a roster of specialized sub-agents, each with exactly one job and a fresh, small context. The coordinator runs on Haiku, carries no skills and no CMS access, and therefore physically cannot perform a phase inline. It can only delegate and bridge compact results. That constraint isn’t a limitation; it’s the whole cost and correctness model.
Each phase’s model never sees the other phases’ context, so prompt-cache reads stay small. A single agent doing every phase in one growing context ends up re-reading that context on nearly every turn. Keeping phases isolated also removes the temptation for the orchestrator to “just do it itself” when delegating would be cheaper or safer, and it means a post is never judged by the same context that wrote it.
The fleet, by phase:
| Agent | Model | Scope | Hard constraint |
|---|---|---|---|
| SEO Auditor | Haiku | Diff the published corpus, re-score changed posts | Read-only; script-driven, never content_list |
| Content Strategist | Haiku | Turn scores into an update queue + topic queue | Zero CMS calls by default |
| Content Writer | Sonnet | Write one net-new Spanish draft | Never publishes, never updates existing posts |
| Content Updater | Haiku | Surgical gap-fixes on one existing post | One content_update per invocation |
| Thumbnail Generator | Haiku | Generate the hero via Gemini, upload to R2 | Touches hero_image and nothing else |
| Content Reviewer | Haiku | Editorial QA gate, fail-closed | Read-only; judges, never fixes |
| Content Publisher | Haiku | Ship the post | Refuses without a passing review on disk |
| Pipeline Meta-Auditor | Sonnet | Weekly audit of the pipeline itself | Read-only; cross-checks the week's artifacts |
The mechanical parts (corpus diffing, scoring, queue ranking) are not model judgment at all. They’re bundled deterministic scripts driven by the public sitemap and a score cache, so the model’s job is orchestration and the handful of judgment calls that actually need judgment (ranking new topics by conversion intent, catching a fabricated statistic). This is the least glamorous and most important decision in the whole system: anything a script can compute, a script computes. The model never re-derives a queue by hand, and it’s banned from calling the CMS’s list endpoint entirely, because that endpoint returns full post bodies with no field projection and would blow up every context that touched it.
Two kinds of state, split by size
Containers are ephemeral, so every durable byte has to go somewhere explicit. We split state by size:
- The SEO score cache (~80 KB) lives in Cloudflare R2, not in the agent’s context. The coordinator hydrates it with a
curlat cycle start and persists it withwranglerafter the audit. The bytes move disk↔R2 only. The model never reads or writes the file’s contents through its own context, and there’s an explicit rule that if hydration fails, the cycle fails rather than re-auditing the full corpus from scratch. - Small pipeline state lives in a managed memory store: a cycle lock, per-cycle artifacts, an append-only activity log that feeds the daily digest, and a
held/folder of review-failed drafts awaiting a human. Everything there is capped small; the rule is “write summaries, not dumps.”
The key insight is that the score cache is the corpus snapshot. Every agent that needs corpus-wide knowledge (dedup, slug collisions, interlink candidates, category pick-lists) reads the local cache file instead of querying the CMS. That’s what lets a daily audit be incremental (only changed posts re-scored) instead of a 126-post full re-read.
The fail-closed review gate
The thing most people ask about is the publishing step, because there’s no human approval queue anymore. A post that passes review publishes in the same cycle, automatically. That only works because the reviewer is a separate agent with a fresh context, deliberately not the agent that wrote the post, and because it fails closed.
The reviewer runs a fixed checklist, not open-ended vibes. Missing hero image, missing byline, or missing SEO title/description is a hard fail regardless of how good the writing is. It re-scores the post against the same dimensions the auditor uses: AEO structure, schema completeness, topical coverage, conversion infrastructure. It also runs two checks I care most about:
- A fabricated-stat scan. Every percentage or “studies show” claim must carry an inline link to an allowlisted authoritative domain (SEP, INEGI, STPS, CENEVAL, and so on). A stat with no source is a fail. For answer-engine optimization this is the single highest-leverage rule: a model won’t cite you if your facts can’t be traced.
- Product-accuracy against a single source of truth. A
conocenos-mejor.mdfile holds the verified facts about the school: prices, RVOE, modality, requirements. If the reviewer can’t read that file, the product-accuracy dimension fails rather than silently degrading to “unverified.”
The publisher is then a strict gate, not an agent that makes decisions: it verifies a passing review report exists on disk (and is less than a week old), re-runs a pre-flight check, and makes exactly one publish call. There’s no force flag.
The human still exists, just after the fact instead of in the middle of every step. Every cycle ends with a digest email summarizing what published, what updated, what was researched, and what was held. Anything wrong gets unpublished and fed back into the next session. The blast radius is bounded by design: one post per cycle, everything reversible, and a reviewer that would rather hold a good post than ship a bad one.
A day in the life
One session, nine steps: claim the cycle lock → hydrate the score cache (or fail) → audit → strategy → produce exactly one item (a net-new draft or an update, alternating) → hero image if it’s new → review → publish-or-hold → write the activity log → send the digest → close out. Every phase appends one terse line to the activity changelog as it goes, because that changelog is the durable record: the digest is built from it, and the digest can’t report its own absence.
That last point is the operational truth nobody tells you about autonomous agents: the most likely failure is silence. The daily email is sent from inside a successful session, so if the deployment fails to start a session, there’s no email telling you it failed. We cover that gap with a webhook on session-failure events and a standing rule: no digest by 10:00 → investigate.
Why this compounds for SEO and AI visibility
The 20x didn’t come from keywords; it came from treating an answer engine as a first-class reader. Classic SEO optimizes for a results page. Answer-engine optimization optimizes for being cited in an answer, which rewards the same things a careful reviewer checks: a direct answer near the top, question-shaped headings, an FAQ block a model can lift confidently, structured data, and sourced facts.
Concretely, every post now ships with a direct-answer opening, an FAQ section of at least three real questions, internal links verified against the corpus, inline CTAs to the enrollment pages, and a trust signal (SEP, RVOE, validez oficial) in the body. At the site level we expose an llms.txt and an RSS feed so agents and crawlers discover posts without scraping. Search engines and AI assistants turned out to want the same things: clarity, structure, freshness, and facts that trace.
And on the baseline: we started low. 20x from near-zero is a hard-won, meaningful number, not “we own the internet.” It means we went from invisible to reliably present on the surfaces where our students actually look.
What I’d tell someone building this
Start with the pipeline, not the output. The two decisions that mattered most were splitting the work across fresh, single-purpose agents (no self-grading) and pushing determinism into scripts (the model orchestrates, it doesn’t recompute). Every rule that’s expensive to learn at runtime (a banned list endpoint, a source-of-truth file, a fail-closed checklist) is cheap to write down once.
And keep the human at the last gate, even if it’s after the fact. The point of a managed-agent fleet isn’t to remove judgment; it’s to spend judgment where it counts, on a digest you can read in two minutes instead of a pipeline you babysit for hours.
If you’re building something similar, or you run a school or nonprofit that needs to publish consistently, I’d love to compare notes. You can find me on LinkedIn or X, and Prepa IN at prepain.mx.
Frequently asked questions
What does 'managed agents' mean here exactly?
Anthropic hosts the agent loop in a sandbox. A thin coordinator agent sequences the pipeline and delegates each phase to a dedicated sub-agent that has only that phase's skill and a fresh context. A scheduled deployment fires one session per day.
Do the agents publish without a human?
Yes, but publishing is review-gated. A separate fail-closed reviewer agent must issue a passing verdict, and the publisher refuses to ship without that report on disk. Humans review after the fact through a daily digest email, and anything wrong can be unpublished.
Why split the work into so many agents instead of one?
Fresh context per phase keeps prompt-cache reads small and cost low, and it prevents self-grading: the writer and the reviewer are different agents, so a post is never judged by the agent that produced it.
How do you measure visibility on ChatGPT?
We track how often Prepa IN appears when students and families ask relevant questions in ChatGPT and other AI assistants, alongside Google Search Console impressions and clicks.