Autonomous GTM Experimentation

The autoresearch pattern — originally built by Andrej Karpathy for ML model optimization — is a 630-line feedback loop: modify one variable, run a fixed experiment, measure against a single metric, keep what wins, discard what doesn't, repeat. Karpathy's script ran ~700 experiments in two days and found 20 improvements a human expert missed. Shopify's CEO pointed it at their Liquid templating engine and got 93 automated commits, 53% faster rendering, and 61% fewer memory allocations.

The GTM version replaces the training script with a GTM asset (email, ad, landing page, nurture flow) and the model accuracy metric with a revenue-linked outcome (reply rate, CVR, SQL rate). The loop runs on real traffic, logs everything, and compounds learnings across channels.

Level 1: First Loop (Week 1-2)

Start with cold email. One ICP segment, one metric, no full autonomy yet.

• Choose one ICP segment (e.g., RevOps leaders at 50-500 FTE SaaS companies, UK-based)
• Primary metric: reply rate. Guardrails: spam complaints, unsubscribe rate
• Stack: Clay for list and signals, Instantly or Lemlist for sending, Claude or MindStudio to generate variants

1. Take your current best-performing subject + opener as the baseline
2. Generate 3 challenger variants using an LLM prompt embedding your ICP, offer, and brand guardrails — test one variable at a time (subject only, or opener only, never both)
3. Send each variant to 100+ prospects in the same segment over 48 hours; keep sending the baseline in parallel
4. Measure positive reply rate only — not opens, not total replies
5. Promote a challenger to new baseline only if it beats by +30% relative lift with at least 20 total replies
6. Log hypothesis, what changed, and outcome in a JSON file — this is your experiment journal

By the end of Week 2 you have a working loop, a minimal memory system, and ground truth on what sample size your audience actually needs.

Level 2: Full System — The Autonomous GTM Lab (Week 2-4)

Build the reusable architecture that applies the core loop pattern to every channel with automated execution and shared memory.

The Core Loop (every channel, every time):

1. Define the objective function — one primary metric + 1-2 guardrails (never optimize for anything you wouldn't report to your CEO)
2. Define the action space — enumerate exactly which fields the agent can touch; freeze everything else
3. Set the measurement window — channel-specific (48h email, 3-7d ads, 1-3w landing pages, 7d nurture)
4. Agent proposes hypothesis + one variant, with rationale drawn from the experiment journal
5. Execute via API — no manual deployment
6. Measure against baseline using the same data source as always
7. Keep if it beats baseline; revert if it doesn't; log either way
8. Generate next hypothesis from memory (last N journal entries)
9. Loop

Channel architecture:

• Cold email: Primary metric = positive reply rate. Agent touches subject, opener, CTA, send time. 48h window, 100 sends per variant, 20 total replies minimum. Stack: Clay + Instantly/Lemlist + agent.
• Google Ads: Primary metric = CPA or ROAS. Agent touches headlines and descriptions only (no budgets). 3-7 day window, 400 conversions per variant for 20-30% lift detection.
• Landing pages: Primary metric = CVR (visit to next action). Agent touches H1, subheadline, primary CTA text, social proof block. 1-3 week window, 200-500 visitors per variant.
• Email nurture: Primary metric = conversion to next stage. Agent touches subject, preview text, CTA, send timing. 7 day window, 50 triggered per variant.
• LinkedIn content: Primary metric = click-to-site rate. Agent touches hook (first line), format, CTA, length, post time. 48h window, 500 impressions per variant.
• SEO meta: Primary metric = organic CTR. Agent touches title tag, meta description (fixed URL set). 2-4 week window, 1,000 GSC impressions per variant.

Safety architecture:

Every loop has three layers of protection:

• Budget caps — per-experiment spend ceilings for ads (10-20% of channel budget), plus hard monthly limits with auto-pause. Agent never touches budget settings.
• Rollback thresholds — auto-revert when primary metric drops >30% vs control or any guardrail (spam rate, unsubscribe rate, CPC ceiling) trips. For ads: rollback after two consecutive measurement windows of underperformance.
• HOTL governance tiers: - Tier 0 (auto-deploy): subject lines, body copy variants, send timing, minor CTA text - Tier 1 (human approval queue): offers, pricing page copy, anything mentioning competitors - Tier 2 (no autonomous changes): contracts, legal language, security claims, pricing

Level 3: Multi-Channel Lab (Week 4-6)

Once two or more single-channel loops are running and producing clean journal data, introduce the planner-executor-evaluator architecture that Meta used in their Ranking Engineer Agent (REA), which doubled model accuracy and let three engineers do the work of six.

• Planner agent — reads business objectives and the cross-channel journal, allocates experiment budget by channel based on current confidence and impact potential
• Executor agents — one per channel, each running the core loop within the Planner's constraints
• Evaluator agent — aggregates pipeline and revenue outcomes across channels, identifies cross-channel patterns, flags conflicts, updates the Planner

Cross-channel compounding in practice: timeline hooks consistently outperform problem hooks in cold email for RevOps ICs → ads loop seeds new headlines with timeline framing for the same retargeting segment → landing page loop tests timeline-framed H1 for the same ICP. Learning generated once, applied everywhere.