Eight agents. One GTM team. One approval room.

Multi-agent GTM. Typed handoffs. Shared memory. One reviewUrl rolls up.

Status: orchestrator + 8 agents scaffolded and smoke-tested. Zero real partner launches yet. Architecture until the GTM wedge ships proof. Full status →

Updated 2026-05-06 · roadmap · trust

The eight agents

launch Live wedge

Launch agent

Strategic spine

Positioning, channel selection, launch checklist, and the runPlan that decides which downstream agents activate.

Receives: — (root agent)
Emits: positioning, channels, launch_plan, run_plan
Reuses: skills.js → positioning, campaign-plan, approval-pack

email Live (Resend send wired)

Email agent

Launch announcements + lifecycle

Launch emails, newsletters, lifecycle sequences, follow-up cadences. Sends via Resend after approval.

Receives: positioning, channels
Emits: email_drafts, send_schedule
Reuses: skills.js → email-sequence; resend.js for send

blog-seo Scaffolded

Blog + SEO agent

Owned media + organic

SEO briefs (target query, intent, internal-link plan), blog drafts, metadata (title/description/canonical/OG), refreshes for older posts.

Receives: positioning
Emits: seo_brief, blog_draft
Reuses: NEW skills: seo-brief, blog-draft (Phase 1)

creative Live (image gen opt-in)

Creative agent

Image briefs + assets

Image briefs for hero/social/ad/thumbnail/OG, brand-grounded image generation via Gemini 2.5 Flash (opt-in), variant generation.

Receives: positioning, channels
Emits: image_briefs, image_assets
Reuses: skills.js → visual-concepts; image-gen.js (Gemini)

analytics Live (real GA4 + SC reads)

Analytics agent

Reads + explanations

Pulls GA4, Search Console, Zernio engagement, Resend deliverability. Explains what changed and why. Feeds the experiment agent.

Receives: launch_plan
Emits: metrics, explanation
Reuses: skills.js → weekly-report, anomaly-explainer; live OAuth: GA4, Search Console

experiment Scaffolded

Experiment agent

Next-test designer

Hypothesis, variants, success metric, sample-size estimate, ONE next test (not a roadmap).

Receives: metrics, explanation
Emits: hypotheses, experiment_plan, next_test
Reuses: NEW skill: experiment-design (Phase 1)

approval Live (approval gate today)

Approval agent

Cross-cutting safety wrapper

Approval pack on the signed reviewUrl, audit trail, compliance checks (PII, sender-domain, recipient verification), risk flags.

Receives: * (every other agent's actions)
Emits: approval_pack, audit_log, risk_flags
Reuses: skills.js → approval-pack; existing /runs/:id/approve flow

Handoff graph

Every artifact emitted by an agent has a declared list of downstream agents that subscribe to it. The orchestrator routes; agents never call each other.

From	Artifact	Routed to
`launch`	`positioning`	`creative`, `social`, `email`, `blog-seo`, `experiment`
`launch`	`channels`	`social`, `email`, `creative`
`launch`	`launch_plan`	`approval`, `analytics`
`creative`	`image_briefs`	`social`, `email`, `blog-seo`, `approval`
`social`	`social_posts + publish_schedule`	`approval`
`email`	`email_drafts + send_schedule`	`approval`
`blog-seo`	`seo_brief + blog_draft`	`approval`, `experiment`
`approval`	`approval_pack + risk_flags + audit_log`	— (terminal)
`analytics`	`metrics + explanation`	`experiment`
`experiment`	`next_test recommendation`	— (terminal)

Five principles

Specialized, not generic

Eight agents that each own one job well, instead of one mega-agent trying to do everything. The boundary is by skill, not by topic — 'social' covers all platforms because the publish provider is shared; 'blog-seo' is one agent because briefs and drafts share too much context to split.

Typed handoffs, not chat

Agents communicate via typed artifacts (positioning, social_posts, image_briefs, metrics, etc.) — never freeform chat. The artifact shape determines which downstream agents subscribe. The orchestrator is the only thing that calls agents — agents never call each other directly.

One human command center

All eight agents roll up to /app/gtm — the workspace control surface. Active runs, agent kanban, approvals queue, scheduled work, results timeline. Every action stays approval-gated; the human stays in the loop.

Shared memory across runs

Per-tenant facts (audience refinement, channel preferences, voice samples, past experiments) persist across runs. The next launch reads what the previous one learned. Memory writes are append-only with full audit log.

Repo-aware from the start

Every agent receives the repoContext (routes, recent commits, README excerpt) the calling agent gathered. The launch agent uses it for positioning; the blog-seo agent uses it for internal-link planning; the creative agent uses it for visual cues.

Try it

From any agent runtime that can fetch — Cursor, Claude Desktop, Codex, Lovable, Bolt, OpenClaw, custom. The wedge tool spawns a coordinated multi-agent run.

POST https://chieflab.io/api/mcp
Authorization: Bearer clp_dev_<your-key>
Content-Type: application/json

{
  "jsonrpc": "2.0", "id": 1,
  "method": "tools/call",
  "params": {
    "name": "chiefmo_gtm_run_start",
    "arguments": {
      "goal": "Launch this product and get our first 100 users",
      "productUrl": "https://yoursite.com",
      "repoContext": {
        "framework": "next.js",
        "routes": ["/", "/pricing"],
        "recentCommits": ["feat: launch", "fix: SEO meta"]
      }
    }
  }
}

Returns a runId, the picker's runPlan (which agents activated and why), and links to /app/gtm (command center) + chieflab.io/runs/:id (signed reviewUrl).

Open the command center.

Workspace owners see every agent's work-in-progress, approvals, scheduled actions, and results in one place.

Open /app/gtm → Give to your agent Roadmap