Design a multi-agent orchestrator skill (likely /market, run from ~/Projects in the same dispatch-specialized-subagents style as Sam's /research and /ideate) that gives a solo operator running a small B2B consulting/marketing-services business (initial user: SWM consulting) an end-to-end marketing co-pilot: it audits existing website content for quality/SEO/conversion, generates social and email content with a posting cadence/calendar, critiques all produced content and strategies from multiple perspectives, suggests local marketing ideas, and plans (and optionally executes) lead generation — while staying general enough to serve other small businesses.

Depth: standard · Domain: engineering · Project: — · Generated 2026-06-02 14:20 PDT

TL;DR

Problem framing

Design a multi-agent orchestrator skill (likely /market, run from ~/Projects in the same dispatch-specialized-subagents style as Sam's /research and /ideate) that gives a solo operator running a small B2B consulting/marketing-services business (initial user: SWM consulting) an end-to-end marketing co-pilot: it audits existing website content for quality/SEO/conversion, generates social and email content with a posting cadence/calendar, critiques all produced content and strategies from multiple perspectives, suggests local marketing ideas, and plans (and optionally executes) lead generation — while staying general enough to serve other small businesses.

Success criteria

Constraints

Non-goals

Candidate approaches

Linear Deliverable Pipeline (the /research clone) (recommended)

Conservative incremental — directly mirror /research and /ideate as a single monolithic orchestrator with fixed sequential phases.

One /market orchestrator skill that, given a business-profile.json plus a website URL, runs a fixed phase sequence in a single dispatch tree: (1) website-auditor subagent crawls and scores pages, (2) strategist subagent sets positioning and channels from the audit, (3) content-generator subagent emits social posts + an email + a dated calendar, (4) a multi-perspective critic pass reviews every artifact, (5) a packager assembles one marketing-deliverable.md. Plan-only by default; lead-gen is a planned section, never executed. Each subagent writes a typed JSON contract the next stage consumes, so outputs are auditable end-to-end.

Key components: Orchestrator skill manifest reusing /research dispatch conventions; business-profile.json schema (industry, ICP, tone, locale, goals); website-auditor subagent (page crawl -> SEO/conversion/content findings JSON); content-generator subagent (posts + email + calendar JSON); multi-perspective critic subagent (SEO/brand/conversion/skeptic personas); packager that emits a single dated marketing-deliverable.md

Modular Capability Menu (independent specialist skills) (alternative)

Modular pipeline + on-demand menu — decompose into several independently-runnable skills the user invokes per task, with a thin shared profile.

Instead of one monolithic run, ship a family of small skills — /market-audit, /market-content, /market-critique, /market-local, /market-leadgen — each independently runnable and each a mini-orchestrator over its own specialists. They share a common business-profile.json and a conventions file for I/O contracts, so any skill's JSON output can feed another's input, but the user picks what to run when. A lightweight /market index skill lists capabilities and recommends an order for first-time users. Critique is itself a reusable skill any other can call.

Key components: Shared business-profile.json + I/O contract conventions doc; /market-audit skill (website findings); /market-content skill (posts/email/calendar); /market-critique reusable review skill; /market-local + /market-leadgen (plan-only) skills; /market index skill describing the menu and suggested sequence

Plan-and-Execute Gated Automation Loop

Plan-and-execute with explicit human gates — a stateful campaign loop that proposes actions and executes only the ones the operator approves.

A /market skill that produces a plan AND maintains a persistent campaign-state.json (calendar items, outreach targets, lead-gen tasks) with each item in a draft -> approved -> executed lifecycle. The default run is plan-only and surfaces a numbered approval queue; the operator explicitly authorizes items, after which gated execution agents (e.g. draft outreach emails, prep posting payloads, generate lead lists) act — but actual sending/posting is staged as copyable, ready-to-fire artifacts plus an approval log, never auto-fired without authorization. Re-running the skill reconciles state and proposes next actions.

Key components: Persistent campaign-state.json with per-item draft/approved/executed status; Approval-queue UX in the deliverable (numbered, opt-in); Gated execution agents (outreach drafting, lead-list prep, post payloads); Audit/approval log recording who authorized what and when; Reconciliation pass that diffs state across runs

SWM-Opinionated Playbook Engine (contrarian)

Contrarian — reject generic configurability; encode an opinionated B2B-consulting marketing playbook with strong defaults, generalizing only by swapping the playbook, not by abstracting everything.

Contrarian bet: a thin orchestrator wrapped around a hard-coded, opinionated playbook for solo B2B consulting/services marketing (SWM's actual situation) — fixed channel priorities (LinkedIn + targeted email + local SEO), pre-baked content archetypes, a named 90-day cadence, and built-in critique heuristics that reflect what works for low-volume high-trust services. Generalization is achieved by authoring alternative playbook files (e.g. ecommerce.playbook, restaurant.playbook), not by a maximally generic profile abstraction. Subagents fill in the playbook's slots rather than deciding strategy from scratch, so output is sharper and faster but more domain-locked per playbook.

Key components: Opinionated swm-consulting.playbook (channels, archetypes, cadence, critique rules); Playbook schema so new verticals are authored, not configured; Slot-filling content + audit subagents driven by the active playbook; Built-in critique heuristics encoded as playbook rules; Thin orchestrator that selects and applies a playbook

Internal context

Prior projects

Prior decisions

Internal risks

Synthesis

# Synthesis: A multi-agent /market co-pilot that audits a small business's website, generates critiqued social/email content with a cadence, suggests local marketing, and plans gated lead-gen — general enough to serve businesses beyond SWM

Where the approaches agree

  • All four assume the build must reuse Sam's proven multi-agent scaffolding — orchestrator + dispatched specialists, four-section dispatch contracts, anti-pattern caps, and a citation-audit fold — rather than inventing a new shape [memory: project_deepresearch.md] [memory: project_idealab.md] [memory: feedback_multiagent_three_folds.md].
  • All four treat the multi-perspective critique as load-bearing, and three of them (linear, capability-menu, playbook) explicitly inherit the resume-reviewer lesson that critique should be a swarm of separate persona agents, not one omni-critic, because a mega-critic hit a 30% fabrication rate and a long-context cliff while the swarm hit 0% [memory: project_resumereviewer.md].
  • All four accept that lead-gen/posting must be gated, opt-in, and emit copyable artifacts — never auto-fired — honoring Sam's standing no-autonomous-execution rule [memory: feedback_agents_no_execute.md].
  • All four converge on the structural insight that the critique pass and final assembly are *guarantees the project requires*, and that only a central orchestrator can enforce a guarantee — the capability-menu red-team makes this explicit, arguing optional menu items convert load-bearing success criteria into things that "happen by luck."
  • All four implicitly accept the JSON-schema-per-stage contract as the inter-agent glue, mirroring /research's `schemas/*.json` layout [memory: project_deepresearch.md].

    • Where the approaches diverge

  • **Monolithic vs. modular** (axis 1): the linear pipeline bakes all phases into one dispatch tree; the capability-menu fragments into five independently-runnable skills sharing a thin profile. The menu bets loosely-coupled skills can share contracts on disk without a central enforcer; the linear approach bets they cannot.
  • **Plan-only vs. plan-and-execute** (axis 2): the linear, menu, and playbook approaches are plan-only advisory; the gated-execution loop pushes hardest on execution with a persistent `campaign-state.json` and a draft→approved→executed lifecycle.
  • **Generic vs. opinionated** (axis 3): the playbook engine rejects generic configurability, hard-coding a B2B-consulting channel mix (LinkedIn + email + local SEO) and generalizing by authoring new playbook files; the other three lean on a generic `business-profile.json` abstraction.
  • **Sequential pipeline vs. on-demand menu** (axis 4): the linear approach runs a fixed sequence regardless of what the operator wants; the menu lets the operator invoke any single capability per task.
  • **Where state lives**: only the gated loop introduces mutable cross-run state — a sharp departure, since no prior skill in Sam's stack (deep-research, idea-lab, resume-reviewer) maintains persistent state between runs [memory: project_resumereviewer.md].

    • What the external evidence says

  • A fixed sequential-pipeline pattern — Agent A hands typed output to Agent B — is a recognized, recommended multi-agent shape, and monolithic agents are argued to suffer reliability problems that decomposition fixes; but this is vendor advocacy with no benchmarks, not measured evidence [google-adk-multi-agent-patterns-2025].
  • Aggregating critiques from multiple independent agents yields higher-quality critique than a single reviewer, and notably critique *diversity degrades when agents see each other's critiques* — supporting separate, isolated persona critics over a shared or debating panel [multicritique-multi-agent-feedback-2024].
  • A JSON schema can turn an LLM step into a composable pipeline stage where "the schema is the contract," supporting the menu's inter-skill handoff bet — but the author cautions this pattern is unsuitable for open-ended generation and that model confidence should not gate unsupervised changes [structured-cli-output-as-pipeline-glue-kinney]. CLI design guidance reinforces small composable units plus discoverability via built-in help and next-command suggestions [command-line-interface-guidelines-clig].
  • Orchestrated multi-agent systems are framed as deriving value from coordination over individual agents, with MCP enforcing schema/auditability on tool access — but the framework is enterprise-scale, illustrated almost entirely through financial underwriting, with impact numbers sourced from vendor blogs, not peer review [orchestration-multi-agent-systems-architectures-protocols-2026].
  • Human-in-the-loop approval (request→classify-risk→notify→decide→execute, with an audit trail) is a real pattern, but its own stated weakness is approval fatigue causing reviewers to rubber-stamp — and it is asserted "validated in production" with no data [agentic-patterns-human-in-loop-approval-framework-2026]. Audit-log guidance recommends append-only, identity-scoped records but is vendor content with no validation [loginradius-auditing-logging-ai-agent-activity-2026].
  • CAN-SPAM applies to ALL commercial email including B2B with no bulk exception; each violating email risks up to $53,088, and senders must include a valid physical address, honest headers, and a working opt-out honored within 10 business days — a hard legal floor for any outreach artifact [ftc-can-spam-compliance-guide-business-2024].
  • For B2B professional services, digital content/event engagement positively drove leads and won opportunities while in-person events did not [wang-b2b-content-marketing-professional-services-2017]; relatedly, "popular ≠ effective" — email ranks #1 in popularity but #24 in effectiveness, SEO #2 popular but #25 effective, and firms under-invest in brand (~32/68 vs. a 46/54 benchmark) [considered-content-b2b-effectiveness-blueprint-professional-services-2024].
  • A structured social-media calendar is recommended to prevent inconsistent posting, sustainable at ~2-3 hrs/week, mixing owned and curated content — but this is experiential, undated practitioner guidance with no empirical backing and a provenance discrepancy [sba-social-media-calendar-2024].
  • Convention-over-configuration speeds delivery via opinionated defaults but raises the learning curve and "removes some problems while introducing others" — the core tradeoff the playbook approach hinges on [convention-over-configuration-opinionated-framework-tradeoff].

    • What the internal context says

  • /research and /ideate are the canonical references: a fixed structured pipeline was chosen over dynamic dispatch (15x vs 5-10x tokens, easier to debug), so /market should default to a fixed shape and reuse research-searcher/reader/citation by name rather than forking them [memory: project_deepresearch.md] [memory: project_idealab.md].
  • Phase 1 of every emitted plan must be validation, never build — and the right gate here is a real first-run smoke against the SWM site, since both prior skills reached "v1 implemented" with end-to-end validation deferred and resume-reviewer surfaced granularity bugs only on the real fixture [memory: project_idealab.md] [memory: project_resumereviewer.md].
  • Replace LLM scoring with deterministic Python where possible — the website-audit (meta tags, headings, link checks) should be deterministic like the ATS keyword scorer, not LLM-guessed [memory: project_resumereviewer.md].
  • The SWM target is a JS-rendered Next.js 16 single-page app on Vercel with placeholder pricing and soft case-study metrics; content generation must not present draft facts as final, and the crawl mechanism (orchestrator fetch tool vs. user-pasted DOM) is unresolved [memory: project_swmconsulting.md].
  • SWM starts from a zero-audience cold start and Medium-not-on-site-blog distribution, so a content calendar should not assume an audience or propose a blog engine [memory: user_writing.md].

    • Where the red-team pushes back hardest

  • **Linear pipeline — critical:** the website-auditor cannot read the JS-rendered SWM site under the no-execution constraint, so every downstream stage runs on hallucinated page content; the crawl mechanism must be resolved before building. Also flagged: it produces a one-shot document with no recurring value and is abandoned after one run.
  • **Capability-menu — critical:** the reusable /market-critique skill cannot run as a nested call without violating the structurally-enforced "no agent calls another agent" cap [memory: feedback_multiagent_three_folds.md]; making it top-level re-introduces "operator skips critique," so the two load-bearing guarantees (every artifact critiqued, one coherent deliverable) happen only by luck.
  • **Gated-execution loop — two criticals:** the draft→approved→executed lifecycle risks re-implementing autonomous execution under a euphemism, colliding head-on with [memory: feedback_agents_no_execute.md]; and generated cold outreach can violate CAN-SPAM per-email the moment it is sent [ftc-can-spam-compliance-guide-business-2024]. Its sharpest contrarian point: a zero-audience operator has a content-and-distribution problem, not a state-tracking problem [memory: user_writing.md].
  • **SWM playbook — critical:** "swap the playbook" is a generalization facade that relocates the work onto unbudgeted per-vertical playbook authoring (strategy, not configuration), so the generalization success criterion is likely never met. Also: hard-coded opinion rots silently and inverts Sam's cite-your-tactics source-hierarchy rule; the playbook can bias its own critic into agreement.

    • What's still open

  • **Crawl mechanism:** no source resolves how a subagent ingests the rendered SWM SPA without autonomous execution — orchestrator-side fetch/render tool vs. user-pasted DOM is undecided and blocks the linear and any audit capability [memory: project_swmconsulting.md].
  • **Evidence-scale mismatch:** the channel-priority evidence is drawn from large-enterprise B2B professional services and explicitly cautioned as not transferring to small business or a cold start [wang-b2b-content-marketing-professional-services-2017] [considered-content-b2b-effectiveness-blueprint-professional-services-2024] — so what the *right* channel mix is for a solo zero-audience operator is unresolved.
  • **Apparent conflict on email/SEO:** the SBA calendar guidance treats social/email cadence as a default win [sba-social-media-calendar-2024], while the effectiveness blueprint ranks email #24 and SEO #25 in effectiveness despite their popularity [considered-content-b2b-effectiveness-blueprint-professional-services-2024]; the Decider should note these point in different directions for a content-calendar capability.
  • **Cold-start distribution:** every approach assumes content reaches someone, but the underlying SWM problem is having no audience; no source addresses how to bootstrap distribution from zero [memory: user_writing.md].
  • **Persistent state safety:** where mutable cross-run state lives for a local Claude skill, and how reconciliation gets ground truth on what the human actually sent, is unresolved — the audit-log references are aspirational vendor guidance [loginradius-auditing-logging-ai-agent-activity-2026] [agentic-patterns-human-in-loop-approval-framework-2026].
  • **Critique-as-guarantee mechanism:** how to bake the critique pass into every content path without nesting agents (the cap that breaks the menu) is open; the linear/orchestrator path appears to satisfy it, but that has not been validated against a real run [memory: feedback_multiagent_three_folds.md].

    • Red-team review

    Modular Capability Menu (independent specialist skills)

    Kill in 6 months: By month 6, this fails because the operator runs only /market-audit and /market-content ad hoc, skips the optional /market-critique step, and never assembles a coherent deliverable — so the build delivers scattered fragments and silently misses the project's central 'every artifact passes critique' and 'coherent deliverable' success criteria.

    Contrarian position: This is the wrong approach because the project's hard requirements — every artifact must pass multi-perspective critique and the run must return one coherent deliverable — are guarantees that only a central orchestrator can enforce, and making critique and assembly optional menu items the operator chooses to invoke converts the two load-bearing success criteria into things that happen by luck; a fixed pipeline that bakes critique and packaging into the path is strictly safer for a solo operator who will not reliably orchestrate five skills by hand.

    Failure modes

    high Decentralized I/O contracts drift between skills until one skill's output silently no longer feeds another's input.
    Trigger: A field is added to /market-audit's findings JSON (e.g. a new severity tier or page-level key) without a central orchestrator enforcing a shared schema, so /market-content and /market-critique keep consuming the old shape and either crash or silently ignore the new data. · Mitigation: Put the I/O contracts in versioned JSON Schemas under a single shared lib (copying deep-research's schemas/*.json layout) and have every skill validate its inputs against the schema at load, failing loudly on mismatch rather than degrading silently.
    high The 'coherent single deliverable' success criterion is never met because the operator runs skills piecemeal and no stage assembles a unified marketing deliverable.
    Trigger: A solo operator invokes /market-audit and /market-content on separate days and never runs an assembling/packager step, leaving scattered per-skill JSON and markdown that no human or agent ever stitches into one coherent strategy.
    medium First-run discoverability collapses: the solo operator does not know which skill to invoke first or in what order.
    Trigger: A new user runs the family of skills with no enforced entry point; the /market index skill is itself optional and easy to skip, so the operator picks /market-content before /market-audit and generates content with no positioning or audit grounding. · Mitigation: Make the /market index the only documented/symlinked entry point and have it refuse to recommend content/leadgen until a business-profile.json and at least one audit artifact exist on disk.
    critical The reusable /market-critique skill cannot run because each parent skill invokes it as a sub-agent, violating the structurally-enforced 'no agent calls another agent' cap.
    Trigger: A /market-content run tries to call the /market-critique skill as a nested agent to satisfy the 'every artifact passes multi-perspective critique' criterion, which the deep-research/idea-lab pattern forbids (no subagent is granted the Agent tool). · Mitigation: Make critique a separately-invoked top-level skill the operator runs against produced artifacts, not a nested call — but this re-introduces the discoverability and 'operator skips it' failure rather than removing it.
    medium Maintenance cost multiplies: five independent skill manifests, install symlinks, and conventions docs diverge and rot.
    Trigger: Greenfield build (no existing /market lib to fork per internal-context open_risks) means each of the five skills carries duplicated dispatch boilerplate, caps, and install wiring; a change to the dispatch-contract template must be hand-propagated to all five. · Mitigation: Factor all shared dispatch/caps/install logic into one shared lib that every skill imports, so the five manifests are thin shells over common code.

    Hidden assumptions

    Plan-and-Execute Gated Automation Loop

    Kill in 6 months: By month 6, this fails because the persistent campaign-state.json drifts permanently out of sync with what the operator actually sent, the reconciliation pass starts re-proposing or double-firing items, the operator loses trust in the loop, and reverts to one-shot plan-only runs that delivered the same value without the state machine.

    Contrarian position: This is the wrong approach because a solo operator with zero audience does not have a state-tracking problem, they have a content-and-distribution problem; building a draft->approved->executed lifecycle, reconciliation, and an approval log adds the most build risk and the most direct collision with the no-autonomous-execution rule to produce machinery that orchestrates actions nobody will see, when a plan-only deliverable would have delivered identical real-world value at a fraction of the complexity.

    Failure modes

    high The persistent campaign-state.json becomes the single point of failure and silently corrupts or drifts out of sync with reality across re-runs.
    Trigger: A reconciliation pass diffs state but has no ground truth for whether a 'copyable' artifact was actually sent or posted by the human, so the operator hand-fires an email, forgets to mark it executed, and the next run re-proposes or double-counts it. · Mitigation: Require the operator to confirm each item's real-world outcome at the start of every reconciliation run (an explicit 'what did you actually send since last time' gate) before any new proposals are generated.
    critical The draft->approved->executed lifecycle re-implements autonomous execution under a euphemism and collides head-on with Sam's hard no-autonomous-execution rule.
    Trigger: Pressure to make the loop deliver 'real recurring value beyond a one-shot document' pushes the 'gated execution agents' from staging copyable artifacts toward actually calling send/post APIs, which is exactly the black-box self-marking-done behavior feedback_agents_no_execute.md rejected. · Mitigation: Structurally forbid any send/post/network-write tool from the execution agents' allow-list; the only permitted output is a file artifact plus an approval-log entry, enforced by the dispatch-contract Allowed-tools list.
    high Approval capture in a CLI conversation is ambiguous and lossy, so the audit/approval log records authorizations that the operator never clearly gave.
    Trigger: There is no web UI; the operator approves items by typing free text like 'do 1, 3, and the email' across multiple turns, and the orchestrator must parse intent, mis-attributing approval to the wrong numbered item or treating a question as a go-ahead. · Mitigation: Require approval as an explicit structured token (exact item IDs in a fixed format) and echo back a confirmation list the operator must affirm before any execution agent runs.
    critical Generated outreach emails violate CAN-SPAM the moment they are sent, exposing the operator to per-email statutory penalties.
    Trigger: The lead-list-prep and outreach-drafting agents produce cold B2B emails to scraped or purchased contacts without a valid physical postal address, a functional unsubscribe mechanism, or honoring prior opt-outs, and the operator fires the ready-made artifact as-is. · Mitigation: Bake CAN-SPAM-required elements (physical address, working unsubscribe, accurate subject/header) into the outreach artifact template and refuse to emit any outreach draft missing them; flag that lead lists from scraped sources carry independent legal/consent risk the skill cannot clear.
    high The stateful loop produces near-zero marketing value because the underlying business has no audience and the calendar items go to an empty room.
    Trigger: SWM starts from a cold start with zero audience and Medium-only distribution; the loop diligently tracks draft->approved->executed status for posts and outreach that have no reach, so the elaborate state machine optimizes a process whose output nobody sees.
    medium Build complexity of the stateful reconciliation loop blows the budget and never reaches a real first-run smoke against the SWM site.
    Trigger: campaign-state versioning, diff/reconciliation, lifecycle transitions, and approval-log design are all greenfield with no fork-able prior art, and prior skills (deep-research, idea-lab) all reached 'v1 implemented' with end-to-end validation deferred, so the loop ships untested. · Mitigation: Gate the entire stateful loop behind a Phase-1 validation spike that proves a single plan->approve->stage->reconcile cycle works on the real SWM site before building multi-item state or versioning.

    Hidden assumptions

    Linear Deliverable Pipeline (the /research clone)

    Kill in 6 months: By month 6, this fails because the operator runs it once against SWM, gets a static one-shot marketing-deliverable.md with no cadence, reconciliation, or follow-through, and never re-invokes it because a linear document-generator delivers no recurring value after the first run.

    Contrarian position: This is the wrong approach because marketing is an iterative, stateful, recurring activity and a fixed linear deliverable pipeline structurally cannot capture that loop; copying the /research shape optimizes for build-safety and pattern-fidelity over actually solving the operator's recurring co-pilot need, producing a polished one-shot artifact that is abandoned after a single run.

    Failure modes

    critical The website-auditor stage cannot actually read the target site, so every downstream stage runs on hallucinated page content.
    Trigger: The initial and only real target (SWM) is a JS-rendered Next.js 16 single-page app on Vercel, and the no-autonomous-execution constraint forbids the subagent from running a crawler; with no resolved orchestrator-side fetch/render mechanism the auditor either receives raw un-rendered HTML or nothing. · Mitigation: Resolve the crawl mechanism before building the pipeline: have the orchestrator pre-fetch rendered HTML with a fetch/render tool and pass it as a typed input to the auditor, or require user-pasted rendered DOM, so the auditor never fetches and never guesses.
    medium A strictly linear pipeline forces a full 5-stage run even when the operator wants only one capability, burning tokens and time for a single audit or a single batch of posts.
    Trigger: The operator invokes /market wanting just a website audit (or just content), but the fixed phase sequence runs strategist, content-generator, critic, and packager regardless. · Mitigation: Add a phase-selection flag that lets the orchestrator short-circuit the sequence after a named stage while still emitting a valid partial deliverable contract.
    high Content and email generation publishes unverified or stale claims as if final.
    Trigger: SWM pricing is still a placeholder TODO and several case-study facts (805 Sign Guys timeline/metrics) are soft drafts; the content-generator pulls these from the business profile and emits them as ready-to-use copy. · Mitigation: Mark every profile field with a verified/draft status and have the critic's claim-audit fold hard-fail any artifact that surfaces a draft-status fact as a final claim.
    high Errors compound silently down the chain because each stage trusts the prior stage's JSON contract without re-grounding.
    Trigger: A bad or empty audit finding feeds the strategist, whose positioning feeds the content-generator; a single early defect (e.g. the auditor mis-scoring an un-rendered page) propagates through every later artifact and the critic reviews only the final text, not the chain integrity. · Mitigation: Give the critic pass an explicit upstream-consistency check that validates each artifact against the original audit inputs, not just the immediately preceding stage.
    medium The single fixed business-profile schema fails to generalize, so the 'runs against a non-SWM business' success criterion is only nominally met.
    Trigger: The minimal profile schema is implicitly tuned to SWM's solo-B2B-consulting shape (ICP, local-SEO angle, five service pillars); a different business type (ecommerce, restaurant) fills the same fields but the linear strategist produces generic output because the pipeline has no domain-specific reasoning.
    high The multi-perspective critic collapses into a single rubber-stamp pass that does not produce genuinely divergent perspectives.
    Trigger: Implementing the SEO/brand/conversion/skeptic personas inside one critic subagent rather than as separate persona agents reproduces the mega-critic anti-pattern, yielding low-disagreement, high-fabrication review. · Mitigation: Implement the critic as separate per-persona agents with per-persona issue caps and verbatim-evidence quoting, mirroring the resume-reviewer swarm that measured genuine disagreement and 0 percent fabrication.

    Hidden assumptions

    SWM-Opinionated Playbook Engine (contrarian)

    Kill in 6 months: By month 6, this fails because the only playbook ever authored is swm-consulting.playbook, the promised second vertical is never written (authoring a playbook is strategy work, not configuration), and the skill is indistinguishable from an SWM-only hard-coded script that fails the generalization success criterion outright.

    Contrarian position: This is the wrong approach because it hard-codes marketing strategy as static opinion, which is precisely the class of claim Sam's own source-hierarchy and citation-audit rules require to be grounded and dated; a low-volume solo consultant's winning channel mix is empirical and operator-specific, so baking it in trades the auditable, defensible 'cite your tactics' discipline for confident advice that cannot be checked and that biases its own critic into agreement.

    Failure modes

    high Hard-coded marketing opinion silently rots into wrong or stale tactics with no signal that it has decayed.
    Trigger: A baked-in tactic (e.g. a fixed LinkedIn + email + local-SEO channel priority or a named 90-day cadence) ages past the point where it reflects current best practice, but because the opinion lives in a static playbook file rather than a cited research pass, nothing forces re-validation and the skill keeps emitting confident, sharp, wrong advice. · Mitigation: Tag every playbook tactic with a source citation and a captured-on date, and run the reused research-searcher/citation fold to re-verify flagged tactics on each run rather than asserting them as fact.
    high The opinionated defaults bias the multi-perspective critic, collapsing the critique pass into a rubber stamp.
    Trigger: Critique heuristics are themselves encoded as playbook rules, so the critic and the generator draw from the same opinionated source; the skeptic/brand/SEO personas validate against the playbook's own assumptions instead of challenging them, producing near-total agreement where resume-reviewer showed genuine critics should disagree (~0.00-0.12 pairwise Jaccard). · Mitigation: Forbid the critic personas from reading the active playbook; feed them only the generated artifact plus the business profile so they evaluate output independently of the opinion that produced it.
    critical Generalization story is a facade: 'swap the playbook' relocates the entire generalization problem onto unbudgeted playbook authoring.
    Trigger: The success criterion 'runs against another business with only a changed profile' is interpreted as 'author a whole new ecommerce.playbook / restaurant.playbook,' so demonstrating generalization requires hand-writing a full opinionated playbook per vertical — which is strategy work, not configuration, and no second playbook gets authored within the build budget.
    high The opinionated channel mix is grounded in evidence drawn from the wrong scale of business.
    Trigger: The playbook's strong defaults (LinkedIn + targeted email + local SEO) are justified by marketing evidence extrapolated from enterprise/mid-market B2B onto a solo operator who starts from a zero-audience cold start, so high-confidence defaults encode tactics that need a sales team, ad budget, or existing list the user does not have.
    medium Slot-filling subagents produce shallow, interchangeable output because strategy is decided before they run.
    Trigger: Subagents fill the playbook's pre-decided slots rather than reasoning about the specific business, so when SWM's real specifics (placeholder pricing, soft case-study metrics, single-page JS site) conflict with the playbook's assumed shape, the agents fill the slot anyway and emit content that is fast and confident but not actually tied to the concrete page or fact. · Mitigation: Require each slot-fill to cite the specific business-profile field or audited page element it draws from, and emit an explicit unfilled flag when no grounding input exists rather than fabricating slot content.

    Hidden assumptions

    Decision

    Recommended: Linear Deliverable Pipeline (the /research clone)

    The linear deliverable pipeline is the only approach whose backbone structurally guarantees the two load-bearing success criteria — every artifact passes multi-perspective critique, and the run returns one coherent deliverable — because a central orchestrator owns both the critique fold and the packager rather than leaving them to operator discretion. It maximally satisfies the binding constraint to reuse Sam's proven /research and /ideate scaffolding (fixed pipeline, four-section dispatch contracts, schema-per-stage, anti-pattern caps) at the lowest build risk, and it is the cheapest path to the real gate: a first-run smoke against the live SWM site. I am recommending it NOT as a naive /research clone but as a recombination that folds in the explored elements proven elsewhere: (1) the critique stage MUST be implemented as a resume-reviewer-style separate-persona swarm (SEO/brand/conversion/skeptic) with per-persona issue caps and verbatim-evidence quoting, never a single omni-critic; (2) the crawl mechanism MUST be resolved before build as an orchestrator-side pre-fetch of rendered DOM passed as typed input (or user-pasted DOM), with deterministic Python scoring for meta/heading/link checks; (3) lead-gen is a plan-only section that emits gated, copyable, CAN-SPAM-compliant artifacts and never auto-fires; (4) a phase-selection flag lets the operator short-circuit to a single capability while still emitting a valid partial-deliverable contract, absorbing the capability-menu's only real advantage without fragmenting into five skills. This recombination keeps the orchestrator's guarantees while neutralizing the linear approach's medium-severity single-capability waste.

    Supporting evidence

    Accepted risks

    Alternative: Modular Capability Menu (independent specialist skills)

    When to pivot: Pivot to the modular capability menu if the first-run smoke and early usage show the operator overwhelmingly invokes a single capability per session (e.g. >80% of runs are audit-only or content-only) AND a versioned shared-schema lib can be proven to enforce I/O contracts across skills without nesting agents — at which point the orchestrator's full-pipeline guarantee is paying for value the operator never uses, and the menu's per-task granularity wins.

    Do not pursue

    Tradeoff matrix

    evidence_strength

    RankApproachNote
    1Linear Deliverable Pipeline (the /research clone)Strongest internal precedent (deep-research/idea-lab fixed pipeline + resume-reviewer critique swarm) plus external multi-agent-pipeline advocacy; the critique-swarm evidence is measured, not vendor-asserted.
    2Modular Capability Menu (independent specialist skills)Schema-as-contract and composable-CLI guidance support it, but the sources caution the pattern is unsuitable for guaranteed passes and open-ended generation.
    3Plan-and-Execute Gated Automation LoopHuman-in-loop approval and audit-log sources are vendor content asserted 'validated in production' with no data, and warn of approval fatigue.
    4SWM-Opinionated Playbook Engine (contrarian)Channel-mix evidence is drawn from enterprise B2B explicitly cautioned as not transferring to a solo zero-audience operator; baking it in violates the cite-your-tactics rule.

    risk

    RankApproachNote
    1Linear Deliverable Pipeline (the /research clone)One critical (crawl mechanism) that is resolvable before build via orchestrator pre-fetch; remaining highs all have in-scope mitigations.
    2Modular Capability Menu (independent specialist skills)Critical 'no agent calls another agent' cap breaks the reusable critique skill, and its mitigation re-introduces the 'operator skips critique' guarantee gap.
    3SWM-Opinionated Playbook Engine (contrarian)Critical generalization facade with no mitigation, plus a self-biasing critic and silently rotting opinion.
    4Plan-and-Execute Gated Automation LoopTwo unmitigated-in-spirit criticals: autonomous-execution collision and per-email CAN-SPAM liability the skill cannot fully clear for scraped lists.

    reversibility

    RankApproachNote
    1Linear Deliverable Pipeline (the /research clone)Stateless one-shot runs with no persisted mutable state; easy to discard a run or pivot the schema without cleanup.
    2Modular Capability Menu (independent specialist skills)Independent skills can be dropped individually, but five install symlinks and divergent manifests add backout cost.
    3SWM-Opinionated Playbook Engine (contrarian)Authored playbooks become embedded strategy assets that are costly to unwind once content depends on them.
    4Plan-and-Execute Gated Automation LoopPersistent campaign-state.json and an approval log create durable mutable state that is the hardest to safely back out of or reconcile.

    effort

    RankApproachNote
    1Linear Deliverable Pipeline (the /research clone)Directly copies the proven /research scaffolding shape; lowest greenfield surface to reach a first-run smoke.
    2SWM-Opinionated Playbook Engine (contrarian)Thin orchestrator is cheap, but hidden cost is per-vertical playbook authoring (expert labor) that the build budget does not cover.
    3Modular Capability Menu (independent specialist skills)Five manifests, install symlinks, and conventions docs multiply greenfield boilerplate beyond a single orchestrator.
    4Plan-and-Execute Gated Automation LoopState versioning, diff/reconciliation, lifecycle transitions, and approval-log design are all greenfield with no fork-able prior art.

    Implementation plan

    For approach: Linear Deliverable Pipeline (the /research clone)

    Build a fixed-pipeline /market orchestrator skill that audits a business website with deterministic Python scoring, generates social/email content and a posting calendar, folds every artifact through a separate-persona critique swarm, and packages one copyable, plan-only marketing deliverable, mirroring Sam's /research and /ideate scaffolding.

    Prerequisites

    Validate the crawl mechanism and critique-as-guarantee

    The decision flags the JS-rendered crawl as the single critical, build-blocking risk and the critique-swarm-without-nesting as an open mechanism question; both must be proven on the real SWM site before any pipeline is built so downstream stages do not run on hallucinated input.

    1. Resolve and prototype the rendered-DOM ingestion mechanism for the SWM SPA — Decide between orchestrator-side pre-fetch of the rendered DOM versus user-pasted DOM, then prototype it against the live JS-rendered Next.js 16 SWM site at ~/Projects/smb-consulting-website. Done when the rendered HTML of all SWM single-page sections (Hero, Services, ScopingTool, Cases, Pricing, Contact) is captured into a typed JSON input blob with no subagent performing autonomous fetch/execution. Verify by confirming the captured DOM contains real SWM copy (e.g. the five service pillars and case-study names), not empty client-side shells. [feedback_agents_no_execute.md]
      Verifies: Neutralizes the linear pipeline's one critical failure mode: the website-auditor cannot read a JS-rendered site under the no-execution constraint, so every downstream stage would run on hallucinated page content.
    2. Confirm the critique pass can be baked into every content path without nesting agents — Validate that the orchestrator can dispatch the persona critics directly on each produced artifact (rather than a content agent calling a critic agent), honoring the structurally-enforced 'no agent calls another agent' cap. Done when a dispatch sequence diagram shows the orchestrator owning both content generation and the critique fold. Verify by checking no subagent in the design is granted the Agent tool. [feedback_multiagent_three_folds.md]
      Verifies: Verifies the open mechanism question of how to guarantee every artifact is critiqued without the agent-nesting cap that breaks the capability-menu alternative.
    3. Manual end-to-end dry run of the intended deliverable against SWM — Using the captured SWM DOM, hand-produce a one-page sample deliverable (a few audit findings, one social post, one email draft, a 1-week calendar slice) to confirm the intended pipeline shape yields concrete, page-specific output, not generic advice. Done when at least three findings reference specific SWM pages/elements (e.g. placeholder pricing, missing /work index, route-unaware nav anchors). Verify each finding maps to a real element in the captured DOM. [project_resumereviewer.md]
      Verifies: Verifies the success criterion that audit findings are concrete and page-tied, and surfaces first-run-only granularity bugs the way resume-reviewer's real-fixture run did, before any code is committed.

    Gate: Rendered SWM DOM is reliably captured as typed input with no autonomous subagent fetch, the critique fold is provably non-nesting, and a hand dry run produced SWM-specific (not generic) findings.

    Scaffold the /market orchestrator and contracts

    With the build-blocking risk resolved, copy the proven /research and /ideate scaffolding shape so the orchestrator owns the guarantees, before any capability logic is written.

    1. Create the tools/market/lib layout and install.sh reusing research scaffolding — Scaffold tools/market/lib (run_state, project_detect, workbench_register, html_render, reporter_helpers) and bin/install.sh symlinking the /market command and skill-specific agents into ~/.claude, with a sanity check that deep-research is installed first (since research-searcher/reader/citation are reused by name). Done when install.sh runs cleanly and the skill is invokable as /market with a no-op stub. Verify the symlinks resolve and the deep-research dependency check fires when it is absent. [project_deepresearch.md]
      Verifies: Verifies the binding constraint to reuse Sam's proven scaffolding rather than fork it, and the prerequisite that cross-skill agent reuse works as it does in /ideate.
    2. Author the business-profile.json schema and the per-stage JSON schemas — Write schemas/business-profile.json (industry, ICP, tone, locale, goals) plus schemas for audit-findings, content-bundle, critique, and marketing-deliverable, mirroring /research's schema-per-stage contract. Done when each schema validates and a SWM business-profile.json instance (seeded from the SWM site facts) passes. Verify the profile schema captures locale for the local-SEO angle and a tier/pricing field flagged as draft-not-final. [project_deepresearch.md]
      Verifies: Verifies the inter-agent JSON-contract glue and the accepted risk that a single profile schema must be testable against a non-SWM business later.
    3. Define the four-section dispatch contracts and anti-pattern caps for all subagents — Write the Objective / Output format / Allowed tools / Task boundaries dispatch contract for the website-auditor, content-generator, and each critique persona, with per-agent tool-call caps, query-length caps, and an explicit allow-list that grants no subagent the Agent tool. Done when every planned subagent has a templated contract. Verify lead-gen/posting agents have no send/post/network-write tool in their allow-list. [feedback_multiagent_three_folds.md, feedback_agents_no_execute.md]
      Verifies: Verifies the mandatory three-folds guardrails and the accepted risk that errors must not compound silently, by constraining each agent's surface up front.
    4. Implement the phase-selection short-circuit flag — Add an orchestrator flag (e.g. --only audit|content|critique) that runs a single capability while still emitting a valid partial-deliverable contract. Done when invoking the flag skips other stages yet produces a schema-valid deliverable. Verify a single-capability run does not dispatch the unused subagents (lower token/time cost).
      Verifies: Verifies the recombination's neutralization of the accepted medium-severity risk that a strictly linear pipeline wastes tokens when the operator wants only one capability.

    Gate: The /market skill installs, all stage schemas validate against a seeded SWM profile, every subagent has a four-section contract with caps and no Agent tool, and the short-circuit flag produces a valid partial deliverable.

    Build the deterministic website auditor

    The auditor is the pipeline's input source and the riskiest-to-hallucinate stage, so it is built first and made deterministic where possible, consuming the typed DOM resolved in Phase 1.

    1. Implement deterministic Python scoring for meta, heading, and link checks — Build a stdlib-leaning Python scorer that consumes the typed rendered-DOM input and emits audit-findings JSON for meta tags, heading structure/hierarchy, and internal/external link health, with atomic matchable units (not whole sentences). Done when running it against the captured SWM DOM produces page-tied findings. Verify findings use atomic units so coverage scores are not artificially zero. [project_resumereviewer.md]
      Verifies: Verifies the lesson that LLM-guessed scoring should be replaced with deterministic Python, and guards against the resume-reviewer granularity bug where non-atomic units produced ~0 coverage.
    2. Add the LLM conversion/content-quality findings layer with source-cited SEO claims — Layer an LLM pass that produces conversion and content-quality findings the deterministic scorer cannot cover, routing any non-obvious 'best practice' SEO/marketing claim through research-searcher/research-citation so tactics are cited, not asserted. Done when the auditor emits prioritized findings combining deterministic and LLM layers. Verify each factual tactic carries a real source ID. [wang-b2b-content-marketing-professional-services-2017, considered-content-b2b-effectiveness-blueprint-professional-services-2024]
      Verifies: Verifies the constraint that marketing/SEO tactics fall under Sam's cite-your-tactics source-hierarchy rule rather than being asserted as fact.
    3. Run the auditor end-to-end against the live SWM site — Execute the full auditor stage against the captured SWM DOM and confirm it reproduces the known real issues (placeholder pricing, missing /work index, route-unaware nav anchors) plus prioritized SEO/conversion findings. Done when the audit-findings JSON validates and lists the known SWM issues. Verify findings are prioritized, not a flat dump. [project_resumereviewer.md]
      Verifies: Verifies the success criterion of concrete page-tied findings and confirms the Phase-1 crawl mechanism survives a full automated stage run.

    Gate: The auditor produces schema-valid, prioritized, SWM-specific findings combining deterministic checks and source-cited LLM judgments, reproducing the site's known real issues.

    Build content generation and the persona critique fold

    Content and its mandatory multi-perspective critique are the project's two load-bearing guarantees; they are built together so no content artifact can exit the pipeline uncritiqued.

    1. Implement the content-generator consuming audit findings and the profile — Build the content-generator subagent that emits social posts, an email draft, and a dated posting calendar as content-bundle JSON, seeded by the audit findings and profile, treating draft facts (placeholder prices, soft case-study metrics) as explicitly unverified. Done when it emits a schema-valid bundle for SWM. Verify no draft price or soft metric is presented as final, and the calendar does not assume an existing audience. [sba-social-media-calendar-2024, considered-content-b2b-effectiveness-blueprint-professional-services-2024]
      Verifies: Verifies the accepted risk and open question that content must not publish unverified SWM draft facts and must account for a zero-audience cold start.
    2. Implement the separate-persona critique swarm (SEO/brand/conversion/skeptic) — Build four isolated persona critic subagents that each see the artifact independently (never each other's critiques), with per-persona issue caps (<=10) and whitespace-normalized verbatim-evidence quoting. Done when each persona emits capped, quote-backed critique JSON for the SWM content bundle. Verify personas are dispatched in isolation and quotes substring-match the source after normalization. [project_resumereviewer.md, multicritique-multi-agent-feedback-2024]
      Verifies: Verifies the load-bearing decision to use a separate-persona swarm over a single omni-critic (0% vs 30% fabrication) and that critique diversity degrades when agents see each other's output.
    3. Add the upstream-consistency check and critique synthesis — Add a synthesizer that dedups/prioritizes the persona critiques AND validates each content artifact against the original audit inputs (not just the prior stage), flagging any claim that drifted from source. Done when a deliberately injected inconsistency (a content claim contradicting the audit) is caught. Verify prioritization is preserved and the consistency check fires on the injected error. [project_resumereviewer.md]
      Verifies: Verifies the accepted high-severity risk that errors can compound silently down the chain, via the in-scope upstream-consistency mitigation.
    4. Add the claim-audit fold over factual marketing claims — Route every factual marketing/SEO claim in the final content and strategy through a research-citation-style audit post-pass that maps each claim to a real source or flags it. Done when running the fold over the SWM content bundle produces a clean claim-to-source map with no unsourced factual tactic. Verify a planted unsourced claim is flagged. [feedback_multiagent_three_folds.md]
      Verifies: Verifies the mandatory citation-audit fold guardrail and the constraint that factual tactics must be grounded in cited sources.

    Gate: Every content artifact passes through the isolated persona swarm, the synthesizer prioritizes and catches an injected upstream inconsistency, and the claim-audit fold flags any unsourced factual tactic.

    Package the deliverable, plan-only lead-gen, and prove generalization

    Final assembly is the second load-bearing guarantee (one coherent deliverable); lead-gen must be proven plan-only and CAN-SPAM-safe; and generalization must be tested against a second business per the success criteria.

    1. Implement the packager emitting one coherent marketing-deliverable — Build the packager that assembles audit, content, calendar, critique, and local-marketing ideas into a single dated marketing-deliverable.md plus an HTML report and a workbench docs-registry row, following the /research output convention. Done when a full SWM run yields one self-contained deliverable. Verify all stage outputs are auditable and cite their inputs. [project_deepresearch.md]
      Verifies: Verifies the load-bearing success criterion of returning one coherent deliverable rather than a monolithic prompt response.
    2. Implement plan-only, CAN-SPAM-compliant lead-gen artifact templates — Build the lead-gen section so it emits gated, copyable outreach artifacts only — every email template bakes in a physical postal address, a working unsubscribe mechanism, and honest headers — with execution agents holding no send/post/network-write tools. Done when the lead-gen output is a copyable artifact set with the compliance fields present. Verify no agent in this path can transmit anything. [ftc-can-spam-compliance-guide-business-2024, feedback_agents_no_execute.md]
      Verifies: Verifies the constraint that lead-gen is plan-only and opt-in, and removes the per-email CAN-SPAM liability that killed the gated-execution-loop approach.
    3. Run the full pipeline against a second non-SWM business — Author a business-profile.json for a second small business and run the complete /market pipeline against its website, changing only the profile. Done when the run produces a schema-valid, business-specific deliverable with no SWM-specific leakage. Verify the profile schema required no structural change to fit the second vertical.
      Verifies: Verifies the success criterion that the skill generalizes with only a changed profile, and the accepted risk that the single profile schema generalizes beyond nominal.
    4. Final full-pipeline smoke against the live SWM site — Run the complete unmodified pipeline end-to-end against the live SWM site as the real first-run gate, capturing token/time cost and any first-run-only bugs. Done when one command yields a complete, critiqued, cited, plan-only deliverable. Verify the deliverable is coherent end-to-end and every prior phase's guarantee holds in the integrated run. [project_idealab.md, project_resumereviewer.md]
      Verifies: Verifies the lesson that prior skills deferred real end-to-end validation, closing the gate the framing requires: a real first-run smoke against the SWM site.

    Gate: A single command produces one coherent, fully critiqued, source-cited, plan-only deliverable for both SWM and a second business, with lead-gen artifacts CAN-SPAM-compliant and no autonomous execution anywhere.

    Kill criteria

    Bibliography

    1. Google Developers (Google ADK team) (2025). Multi-Agent Design Patterns with the Agent Development Kit (ADK). https://developers.googleblog.com/developers-guide-to-multi-agent-patterns-in-adk/ blog Note: not peer-reviewed; treat with appropriate skepticism.
    2. MultiCritique authors (InternLM2 team) (2024). MultiCritique: Improving Critique Ability of LLMs via Multi-Agent Feedback. https://arxiv.org/abs/2410.15287 preprint
    3. Kinney (2025). Structured CLI Output as Pipeline Glue (the schema is the contract). https://stevekinney.com/courses/self-testing-ai-agents/structured-cli-output-as-pipeline-glue blog Note: not peer-reviewed; treat with appropriate skepticism.
    4. Aanand Prasad, Ben Firshman, Carl Tashian, Eva Parish (clig.dev) (2022). Command Line Interface Guidelines. https://clig.dev/ web Note: not peer-reviewed; treat with appropriate skepticism.
    5. Skan AI (2026). Orchestration of Multi-Agent Systems: Architectures and Protocols. https://arxiv.org/abs/2601.13671 preprint
    6. Agentic Patterns (practitioner writeup) (2026). Agentic Patterns: A Human-in-the-Loop Approval Framework. https://agentic-patterns.com/patterns/human-in-loop-approval-framework/ blog Note: not peer-reviewed; treat with appropriate skepticism.
    7. LoginRadius (VP of Engineering) (2026). Auditing and Logging AI Agent Activity. https://www.loginradius.com/blog/engineering/auditing-and-logging-ai-agent-activity blog Note: not peer-reviewed; treat with appropriate skepticism.
    8. U.S. Federal Trade Commission (2024). CAN-SPAM Act: A Compliance Guide for Business. https://www.ftc.gov/business-guidance/resources/can-spam-act-compliance-guide-business institutional
    9. Wang et al. (2017). Content marketing, lead generation and won opportunities in B2B professional services. https://doi.org/10.1016/j.indmarman.2017.11.006 peer-reviewed
    10. Considered Content (2024). The B2B Effectiveness Blueprint: Professional Services Edition. https://www.consideredcontent.com/blog/the-b2b-effectiveness-blueprint-professional-services-edition/ blog Note: not peer-reviewed; treat with appropriate skepticism.
    11. U.S. Small Business Administration (rendered byline: Anita Campbell, Small Business Trends) (2024). Setting Up a Social Media Calendar for Your Small Business. https://www.sba.gov/blog/setting-social-media-calendar-your-small-business institutional
    12. Devopedia (2022). Convention over Configuration. https://devopedia.org/convention-over-configuration web Note: not peer-reviewed; treat with appropriate skepticism.

    Run metadata

    Approaches explored4
    Sources read12
    Sources skipped0
    Red-team iterations0
    Tokens (in / out) 0 / 0