{"slug": "claude-seo-s-19-agent-architecture-how-26-sub-skills-coordinate-technical-audits", "title": "Claude SEO's 19-Agent Architecture: How 26 Sub-Skills Coordinate Technical Audits Without a Central Orchestrator", "summary": "Claude SEO, a technical SEO auditing system, runs 19 specialist agents across 26 sub-skills without a central orchestrator, coordinating instead through a flat skill-composition pattern built on Claude Code's skill system. Skills declare dependencies that the system resolves into a directed acyclic graph executed in topological order, sharing state through a single AuditContext object rather than message passing. The design trades centralized state management and cross-agent workflow optimization for simpler failure modes and easier reuse, with sequential execution producing full audits of 10-15 minutes on a medium site.", "body_md": "Claude SEO runs 19 specialist agents across 26 sub-skills to audit websites for technical SEO, schema markup, Core Web Vitals, E-E-A-T signals, and AI search readiness. The architecture has no central orchestrator. Instead, agents coordinate through a flat skill composition pattern where each sub-skill wraps one or more agents and exposes a uniform interface to Claude Code's skill system.\n\nThis design choice surfaces interesting trade-offs. You get simpler failure modes (no single point of coordination failure), easier agent reuse (skills compose without routing logic), and clearer boundaries (each agent owns a domain). You lose explicit dependency graphs, centralized state management, and the ability to optimize cross-agent workflows.\n\nThe system defines 26 sub-skills that wrap 19 specialist agents:\n\nEach skill exposes a standard interface:\n\n``` php\nclass SEOSkill:\n    def analyze(self, url: str, context: AuditContext) -> SkillResult:\n        \"\"\"Run analysis, return structured findings.\"\"\"\n        pass\n\n    def get_dependencies(self) -> list[str]:\n        \"\"\"Declare which other skills must run first.\"\"\"\n        pass\n\n    def merge_context(self, result: SkillResult, context: AuditContext):\n        \"\"\"Write findings back to shared context.\"\"\"\n        pass\n```\n\nClaude Code invokes skills in dependency order. A skill that needs crawl data declares a dependency on the crawl skill. The skill system resolves the graph and runs crawl first, then passes the enriched context to dependent skills.\n\nTraditional multi-agent systems use a central orchestrator to route tasks, manage state, and handle failures. Claude SEO skips this layer. Coordination happens through three mechanisms:\n\n**1. Dependency declarations**\n\nSkills declare dependencies explicitly. The schema validation skill depends on the crawl skill (needs HTML) and the render skill (needs JavaScript-rendered DOM). The skill system builds a directed acyclic graph and executes in topological order.\n\n**2. Shared context object**\n\nAll skills read from and write to a single `AuditContext` object. The crawl skill writes page HTML, status codes, and redirect chains. The schema skill reads HTML and writes structured data findings. The E-E-A-T skill reads both and writes authority signals.\n\nThis is a shared-memory model. No message passing, no event bus, no coordination primitives. Skills trust the context object to be consistent.\n\n**3. Skill result merging**\n\nEach skill returns a `SkillResult` with findings, warnings, and recommendations. The skill system merges results into the final audit report. No skill sees another skill's output during execution (only through the shared context).\n\nThe shared context model creates predictable failure modes:\n\n**Missing dependencies**: If skill A depends on skill B but B fails, A receives incomplete context. The skill system catches this at graph-build time (missing dependency) or runtime (null context fields). The audit continues with warnings.\n\n**Context pollution**: If skill A writes malformed data to context, skill B may crash or produce garbage output. No schema validation on context writes. The skill system logs exceptions but doesn't roll back context state.\n\n**Concurrent access**: Skills run sequentially (no parallelism). This avoids race conditions but makes audits slower. A full audit takes 10-15 minutes for a medium site.\n\n**Partial failures**: If the crawl skill fetches 80% of pages before hitting rate limits, dependent skills see incomplete data. No retry logic, no partial result handling. The audit completes with gaps.\n\nThe 26 sub-skills layer on top of 19 agents through composition:\n\n| Skill | Agent(s) | Composition Type | \n|---|---|---|\n| Technical SEO | Crawl + Robots + Sitemap | Sequential pipeline | \n| Core Web Vitals | Lighthouse + Render | Parallel then merge | \n| Schema validation | JSON-LD parser + Validator | Sequential with fallback | \n| E-E-A-T analysis | Author + Citation + Expertise | Parallel aggregation | \n| AI search readiness | llms.txt + WebMCP + Agentic Browsing | Independent checks | \n\nThis pattern lets you reuse agents across skills. The crawl agent appears in technical SEO, schema validation, and E-E-A-T skills. The Lighthouse agent appears in Core Web Vitals and performance skills.\n\nComposition types:\n\nThe base system runs offline analysis (crawl, parse, validate). Nine optional extensions add live SEO data:\n\nExtensions follow the same skill interface. They declare dependencies (e.g., Search Console skill depends on crawl skill for URL list) and write to shared context.\n\nThis creates a second failure mode: API rate limits. If the Search Console extension hits quota limits mid-audit, dependent skills see partial data. No backoff, no queue, no retry. The audit completes with warnings.\n\nThe final audit report renders as PDF or Excel using Google Docs and Sheets APIs. The skill system:\n\nThis is a synchronous blocking operation. If the Google API is slow or rate-limited, the entire audit stalls. No async rendering, no background jobs.\n\nClaude SEO's flat agent hierarchy works because:\n\n**Task boundaries are clear**: Each agent owns a well-defined SEO domain. No ambiguity about which agent handles schema validation vs. crawl analysis.\n\n**Dependencies are static**: The dependency graph doesn't change per audit. Crawl always runs before schema validation. No dynamic routing needed.\n\n**Failures are local**: If the backlink agent fails, the rest of the audit completes. No cascading failures (except for hard dependencies like crawl).\n\n**State is append-only**: Skills write findings to context but don't modify existing data. No coordination needed to prevent conflicts.\n\n**Execution is sequential**: No parallelism means no race conditions, no distributed state, no consensus protocols.\n\nThis pattern breaks down when:\n\n``` python\nfrom dataclasses import dataclass\nfrom typing import Optional\n\n@dataclass\nclass AuditContext:\n    url: str\n    html: Optional[str] = None\n    status_code: Optional[int] = None\n    redirects: list[str] = None\n    structured_data: Optional[dict] = None\n    core_web_vitals: Optional[dict] = None\n\nclass CrawlSkill:\n    def get_dependencies(self) -> list[str]:\n        return []  # No dependencies\n\n    def analyze(self, url: str, context: AuditContext) -> dict:\n        # Fetch page, follow redirects, extract HTML\n        response = self._fetch_with_redirects(url)\n        context.html = response.text\n        context.status_code = response.status_code\n        context.redirects = response.history\n\n        return {\n            \"status\": \"success\",\n            \"findings\": {\n                \"crawlable\": response.status_code == 200,\n                \"redirect_chain_length\": len(response.history),\n                \"html_size_kb\": len(response.text) / 1024\n            }\n        }\n\nclass SchemaSkill:\n    def get_dependencies(self) -> list[str]:\n        return [\"crawl\"]  # Needs HTML from crawl skill\n\n    def analyze(self, url: str, context: AuditContext) -> dict:\n        if not context.html:\n            return {\"status\": \"error\", \"message\": \"No HTML available\"}\n\n        # Extract and validate JSON-LD\n        structured_data = self._extract_jsonld(context.html)\n        validation_errors = self._validate_schema(structured_data)\n\n        context.structured_data = structured_data\n\n        return {\n            \"status\": \"success\",\n            \"findings\": {\n                \"schema_types\": list(structured_data.keys()),\n                \"validation_errors\": validation_errors,\n                \"rich_snippet_eligible\": len(validation_errors) == 0\n            }\n        }\n```\n\n**Use Claude SEO's flat agent pattern when:**\n\n**Avoid this pattern when:**\n\nThe flat hierarchy trades orchestrator complexity for simpler agent interfaces and clearer failure modes. It works when your domain naturally decomposes into independent specialists. It breaks when coordination becomes the hard problem.", "url": "https://wpnews.pro/news/claude-seo-s-19-agent-architecture-how-26-sub-skills-coordinate-technical-audits", "canonical_source": "https://dev.to/mech_app_ai/claude-seos-19-agent-architecture-how-26-sub-skills-coordinate-technical-audits-without-a-central-4h7g", "published_at": "2026-10-28 00:08:10+00:00", "updated_at": "2026-10-28 00:11:18.323093+00:00", "lang": "en", "topics": ["ai-agents", "ai-tools", "developer-tools", "generative-engine-optimization"], "entities": ["Claude SEO", "Claude Code"], "also_reported_by": [], "alternates": {"html": "https://wpnews.pro/news/claude-seo-s-19-agent-architecture-how-26-sub-skills-coordinate-technical-audits", "markdown": "https://wpnews.pro/news/claude-seo-s-19-agent-architecture-how-26-sub-skills-coordinate-technical-audits.md", "text": "https://wpnews.pro/news/claude-seo-s-19-agent-architecture-how-26-sub-skills-coordinate-technical-audits.txt", "jsonld": "https://wpnews.pro/news/claude-seo-s-19-agent-architecture-how-26-sub-skills-coordinate-technical-audits.jsonld"}}