Implementation Guide: A/b test ad variants autonomously, pause underperformers, and shift budget within guardrails

Hardware Procurement

Dashboard Wall Display

Dual Monitor Arms

Secondary Monitors (if needed)

Second display for media buyer workstations that currently only have a single monitor. QHD resolution provides sufficient detail for reading performance dashboards with multiple campaign metrics simultaneously.

Uninterruptible Power Supply

Software Procurement

Prerequisites

• Admin or Manager access to all client ad platform accounts: Google Ads Manager Account (MCC), Meta Business Manager with full admin permissions, Microsoft Advertising manager access, and any additional platforms (TikTok, Snapchat, LinkedIn) as applicable
• Google Ads Developer Token obtained from the API Center in the Google Ads Manager Account — requires Basic or Standard access level (22-character alphanumeric string). Apply at least 2 weeks before project start as approval can take 5–10 business days
• Meta System User Token created in Meta Business Manager → Business Settings → System Users. Must have ads_management and ads_read permissions. Token should be non-expiring for production use
• Meta Pixel installed on all client landing pages and conversion points with standard events (Purchase, Lead, AddToCart, InitiateCheckout) properly firing. Verify via Meta Pixel Helper Chrome extension
• Meta Conversions API (CAPI) configured for server-side event tracking — either through direct implementation, a partner integration (Shopify, WordPress plugins), or Madgicx Cloud Tracking add-on. Required to maintain data accuracy post-iOS 14.5 ATT changes
• Google Ads conversion tracking tags installed via Google Tag Manager on all conversion endpoints. Enhanced Conversions enabled where possible
• Minimum 30 days (ideally 90 days) of historical ad performance data across all accounts to establish baseline metrics for AI training and anomaly detection
• Minimum monthly ad spend of $5,000 per platform to generate statistically significant data for autonomous optimization. Accounts below this threshold should use supervised-only mode
• Business-grade internet connection (25+ Mbps, <50ms latency) at the agency office — reliability is more critical than raw speed since API calls run continuously
• Client authorization agreement signed covering: scope of autonomous management, budget guardrails, approved platforms, escalation contacts, liability limits, and right to override all autonomous decisions
• Documented guardrails per client account: maximum daily spend cap, maximum single budget increase percentage, minimum ROAS threshold before pausing, prohibited audience segments, Special Ad Category designations (housing/employment/credit), geographic restrictions, and time-of-day restrictions
• If serving EU audiences: GDPR-compliant Consent Management Platform (CMP) active on all client properties, Data Processing Agreements (DPAs) signed with all SaaS vendors, and documented lawful basis for profiling under GDPR Article 22
• If targeting California residents: CCPA/CPRA opt-out mechanisms implemented and automated decision-making disclosures in privacy policy
• Active Slack workspace (or Microsoft Teams) with a dedicated channel for agent alerts and a channel for each managed client
• Google Workspace or Microsoft 365 account for Google Sheets logging, document storage, and email notifications

Installation Steps

Step 1: Audit Existing Ad Accounts and Define Guardrails

Before any platform setup, conduct a comprehensive audit of all client ad accounts to document current performance baselines, identify existing campaign structures, and collaboratively define the guardrails within which the autonomous agent will operate. This is the most critical step — skipping or rushing it leads to agent misconfiguration and client trust erosion. Meet with the agency's media buying team and document: current ROAS targets per client, maximum acceptable daily spend per campaign and account, minimum performance thresholds before pausing (CTR, ROAS, CPA), any restricted audiences or Special Ad Categories, creative rotation policies, and escalation contacts for budget overrides.

Step 2: Verify and Remediate Conversion Tracking

Autonomous optimization is only as good as the data it receives. Verify that all conversion tracking is properly installed, firing correctly, and attributing conversions accurately. This includes Google Ads conversion tags, Meta Pixel with standard events, and Meta Conversions API (CAPI) for server-side tracking. Use platform-native diagnostic tools to identify and fix any tracking gaps before connecting to the optimization platform.

If CAPI is not yet configured, install via partner integration:

• WordPress: Install 'Facebook for WordPress' plugin → Settings → Conversions API → Enable
• Shopify: Facebook & Instagram channel → Settings → Data sharing → Maximum
• Custom: Use Meta CAPI Gateway (Docker container) or direct server implementation

Step 3: Provision and Configure Primary Optimization Platform

Set up the selected SaaS optimization platform (Optmyzr, Birch, Madgicx, or AdAmigo.ai based on agency needs identified in Step 1). Connect all ad platform accounts via OAuth2 or API tokens. Configure the platform according to the documented guardrails. Start in recommendation-only or supervised mode — do NOT enable autonomous actions yet.

Option A: Optmyzr Setup (Multi-Platform Agencies)

IF campaign ROAS < 2.0 for 3 consecutive days THEN pause campaign AND alert Slack

Option B: Birch Setup (Multi-Platform, Lower Cost)

IF ad set CPA > $50 for last 3 days THEN decrease budget by 20% (min $10/day)

Option C: Madgicx Setup (Meta-Heavy Agencies)

Option D: AdAmigo.ai Setup (Most Autonomous, Meta Only)

- Set performance goals (target ROAS, target CPA)
- Define targeting rules (allowed/blocked audiences)
- Set budget limits (max daily, max per action)
- Configure naming conventions for new ad sets

Step 4: Configure Orchestration Middleware (Make.com or n8n)

Set up the orchestration layer that connects the optimization platform to alerting, logging, CRM, and reporting systems. This middleware handles: routing agent action notifications to Slack/Teams, logging all autonomous decisions to Google Sheets for audit trails, triggering approval workflows for actions above certain thresholds, and syncing data to the client's CRM (HubSpot/Salesforce) and project management tools (Monday.com/Asana).

Make.com Setup

n8n Setup (Alternative)

docker run -d --name n8n -p 5678:5678 -v n8n_data:/home/node/.n8n n8nio/n8n

Step 5: Build Reporting Dashboards in Looker Studio

Create client-facing and internal MSP dashboards in Google Looker Studio that visualize all autonomous agent activity, performance trends, budget allocation changes, and A/B test results. These dashboards are critical for client trust and for the agency team to understand what the agent is doing and why.

Step 6: Configure Slack Alert Channels and Notification Rules

Set up the real-time notification infrastructure that keeps the agency team informed of all autonomous agent actions, budget changes, A/B test conclusions, anomalies, and guardrail breaches. Proper alert configuration prevents alert fatigue while ensuring critical events are never missed.

Step 7: Supervised Operation Phase (Weeks 3–6)

Run the autonomous agent in supervised (recommend-only) mode for 2–4 weeks. During this phase, the agent analyzes performance data, identifies underperforming ads, recommends budget shifts, and suggests A/B test conclusions — but does NOT execute any changes without human approval. This builds trust, validates the agent's judgment against the agency team's expertise, and catches configuration errors before they impact live campaigns.

Step 8: Graduated Autonomy Rollout (Weeks 6–10)

Progressively grant the autonomous agent more authority to execute actions without human approval. Start with low-risk, low-impact actions and gradually increase scope. Maintain alerting throughout so the team always knows what the agent is doing. This phased approach builds confidence while limiting blast radius.

Phase 1 (Week 6–7): Auto-execute LOW-impact actions

Enable auto-execution for:

Still require approval for:

• Budget increases of any size
• Pausing entire campaigns
• Creating new ad sets or audiences

Phase 2 (Week 8–9): Auto-execute MEDIUM-impact actions

Enable auto-execution for:

Still require approval for:

• Budget increases > 20%
• Cross-campaign budget reallocation
• Pausing entire campaigns
• Any changes on Special Ad Category campaigns

Phase 3 (Week 10+): Full autonomy within guardrails

Enable auto-execution for:

Still require approval for:

• Budget changes > 50% on any single item
• Any Special Ad Category campaign changes
• New campaign creation
• Actions that would exceed account-level daily max spend

Configure auto-execution in your platform:

• Optmyzr: Automations → each rule → change Action from 'Suggest' to 'Apply Automatically'
• Birch: Rules → each rule → enable 'Auto-execute' toggle
• Madgicx: Automation → tactics → set to 'Automatic'
• AdAmigo: Enable AI actions per the plan limit (2/day Entry, 10/day Growth)

Step 9: GDPR/CCPA Compliance Configuration

Implement required compliance measures for autonomous ad management, including consent management integration, automated decision-making disclosures, audit logging, and human override mechanisms as required by GDPR Article 22, CCPA/CPRA, and the EU AI Act.

gtag('consent', 'default', {
  'ad_storage': 'denied',
  'analytics_storage': 'denied',
  'ad_user_data': 'denied',
  'ad_personalization': 'denied',
  'wait_for_update': 500
});

Step 10: Final Integration Testing and Go-Live

Conduct comprehensive end-to-end testing of the complete system before declaring the implementation complete. Verify every integration path, alert channel, guardrail enforcement, dashboard accuracy, and failover mechanism. Document results in a testing sign-off sheet.

T1: Agent Action Flow

T2: Guardrail Enforcement

T3: Human Override

T4: Kill Switch

T5: Dashboard Accuracy

T6: Daily Digest

T7: Approval Workflow

Custom AI Components

Ad Performance Analysis Agent

Type: agent A custom AI agent built on n8n or Make.com that periodically retrieves ad performance data from Google Ads and Meta Marketing APIs, analyzes the data against predefined guardrails and KPI thresholds, determines which ads/ad sets to pause, which to boost, and how to reallocate budget. It generates natural-language explanations for each decision and logs all actions. This is the core autonomous decision engine for MSPs choosing the custom-build path instead of or in addition to a turnkey SaaS platform.

Implementation

Architecture Overview

This agent runs as an n8n workflow on a scheduled trigger (every 4 hours during active campaign hours). It follows a Sense → Analyze → Decide → Act → Report loop.

Node 1: Schedule Trigger

• Type: Schedule Trigger
• Config: Every 4 hours, 6AM-10PM in agency timezone
• On weekends: every 8 hours (reduced frequency)

Node 2: Fetch Guardrails

• Type: Google Sheets → Read Rows
• Sheet: 'Guardrails' tab from the master guardrails spreadsheet
• Output: Array of {client, campaign_id, max_daily_spend, min_roas, min_ctr, max_cpa}

Node 3: Fetch Meta Ads Performance

• Type: HTTP Request
• Method: GET
• Output: Array of ad-level performance metrics

GET https://graph.facebook.com/v19.0/act_{ad_account_id}/insights
Authorization: Bearer {system_user_token}

Parameters:
  fields: campaign_name,campaign_id,adset_name,adset_id,ad_name,ad_id,impressions,clicks,spend,actions,action_values,ctr,cpc,cpm
  date_preset: last_3d
  level: ad
  limit: 500

Node 4: Fetch Google Ads Performance

• Type: HTTP Request
• Method: POST
• Output: Ad-level performance metrics for last 3 days

POST https://googleads.googleapis.com/v16/customers/{customer_id}/googleAds:searchStream
Authorization: Bearer {oauth2_access_token}
developer-token: {developer_token}
login-customer-id: {mcc_id}

Body (GAQL):
  SELECT
    campaign.id, campaign.name, ad_group.id, ad_group.name,
    ad_group_ad.ad.id, ad_group_ad.ad.name,
    metrics.impressions, metrics.clicks, metrics.cost_micros,
    metrics.conversions, metrics.conversions_value,
    metrics.ctr, metrics.average_cpc
  FROM ad_group_ad
  WHERE segments.date DURING LAST_3_DAYS
    AND campaign.status = 'ENABLED'
    AND ad_group_ad.status = 'ENABLED'
  ORDER BY metrics.impressions DESC
  LIMIT 500

Node 5: Merge & Normalize Data

• Type: Code (JavaScript)
• Purpose: Normalize Meta and Google data into a unified schema

const metaAds = $input.first().json.meta_ads || [];
const googleAds = $input.first().json.google_ads || [];
const guardrails = $input.first().json.guardrails || [];

const normalized = [];

for (const ad of metaAds) {
  const purchases = (ad.actions || []).find(a => a.action_type === 'purchase') || {value: '0'};
  const revenue = (ad.action_values || []).find(a => a.action_type === 'purchase') || {value: '0'};
  normalized.push({
    platform: 'meta',
    campaign_id: ad.campaign_id,
    campaign_name: ad.campaign_name,
    adset_id: ad.adset_id,
    adset_name: ad.adset_name,
    ad_id: ad.ad_id,
    ad_name: ad.ad_name,
    impressions: parseInt(ad.impressions || 0),
    clicks: parseInt(ad.clicks || 0),
    spend: parseFloat(ad.spend || 0),
    conversions: parseInt(purchases.value || 0),
    revenue: parseFloat(revenue.value || 0),
    ctr: parseFloat(ad.ctr || 0),
    roas: parseFloat(ad.spend) > 0 ? parseFloat(revenue.value || 0) / parseFloat(ad.spend) : 0
  });
}

for (const row of googleAds) {
  const spend = parseInt(row.metrics.costMicros || 0) / 1000000;
  normalized.push({
    platform: 'google',
    campaign_id: row.campaign.id,
    campaign_name: row.campaign.name,
    adset_id: row.adGroup.id,
    adset_name: row.adGroup.name,
    ad_id: row.adGroupAd.ad.id,
    ad_name: row.adGroupAd.ad.name || 'N/A',
    impressions: parseInt(row.metrics.impressions || 0),
    clicks: parseInt(row.metrics.clicks || 0),
    spend: spend,
    conversions: parseFloat(row.metrics.conversions || 0),
    revenue: parseFloat(row.metrics.conversionsValue || 0),
    ctr: parseFloat(row.metrics.ctr || 0),
    roas: spend > 0 ? parseFloat(row.metrics.conversionsValue || 0) / spend : 0
  });
}

return [{ json: { normalized, guardrails } }];

Node 6: AI Decision Engine

• Type: OpenAI Chat (GPT-5.4)
• Temperature: 0.1 (low creativity, high consistency)
• Max tokens: 4000
• User message: Performance data + guardrails from previous nodes (JSON)

SYSTEM PROMPT:

You are an autonomous ad optimization agent for a marketing agency. You analyze ad performance data and make budget allocation decisions within strict guardrails.

Your responsibilities:
1. Identify underperforming ads (below guardrail thresholds for ROAS, CTR, or CPA for 3+ days)
2. Identify top performers (above 150% of target ROAS with statistical significance)
3. Recommend specific actions: pause, reduce budget, increase budget, or reallocate
4. NEVER exceed the max_daily_spend guardrail for any campaign
5. NEVER make changes exceeding 25% of current budget in a single action
6. Provide clear rationale for EVERY decision

Output a JSON array of actions:
[
  {
    "platform": "meta" | "google",
    "action": "pause_ad" | "decrease_budget" | "increase_budget" | "reallocate",
    "entity_type": "ad" | "adset" | "campaign",
    "entity_id": "string",
    "entity_name": "string",
    "current_value": number,
    "new_value": number,
    "rationale": "string explaining why",
    "confidence": "high" | "medium" | "low",
    "risk_level": "low" | "medium" | "high",
    "guardrail_check": "PASS" | "FAIL"
  }
]

Rules:
- Only output actions where guardrail_check is PASS
- If no actions are needed, return an empty array []
- Be conservative — it's better to miss an optimization than to make a bad one
- For A/B tests, require at least 100 conversions per variant and 95% statistical significance before declaring a winner
- Never touch Special Ad Category campaigns (housing, employment, credit)

Node 7: Guardrail Validation Gate

• Type: Code (JavaScript)
• Purpose: Double-check AI decisions against guardrails programmatically (defense in depth)

const actions = JSON.parse($input.first().json.message.content);
const guardrails = $input.first().json.guardrails;
const validated = [];
const rejected = [];

for (const action of actions) {
  const guard = guardrails.find(g => g.campaign_id === action.entity_id ||
    g.campaign_id === 'default');
  
  if (!guard) {
    action.validation = 'REJECTED: No guardrail found';
    rejected.push(action);
    continue;
  }
  
  // Check budget change doesn't exceed 25% rule
  if (action.action === 'increase_budget' || action.action === 'decrease_budget') {
    const changePercent = Math.abs(action.new_value - action.current_value) / action.current_value;
    if (changePercent > 0.25) {
      action.validation = `REJECTED: Budget change ${(changePercent*100).toFixed(1)}% exceeds 25% limit`;
      rejected.push(action);
      continue;
    }
  }
  
  // Check max daily spend
  if (action.action === 'increase_budget' && action.new_value > guard.max_daily_spend) {
    action.validation = `REJECTED: New budget $${action.new_value} exceeds max $${guard.max_daily_spend}`;
    rejected.push(action);
    continue;
  }
  
  action.validation = 'APPROVED';
  validated.push(action);
}

return [{ json: { validated, rejected, summary: `${validated.length} approved, ${rejected.length} rejected` } }];

Node 8: Execute Actions (Meta)

• Type: HTTP Request (for each validated Meta action)

# Pause an ad
POST https://graph.facebook.com/v19.0/{ad_id}
Body: { "status": "PAUSED" }

# Update adset budget
POST https://graph.facebook.com/v19.0/{adset_id}
Body: { "daily_budget": new_value_in_cents }

Node 9: Execute Actions (Google)

Type: HTTP Request — Use Google Ads API mutate endpoint to update campaign/ad group budgets or ad status.

Node 10: Log to Google Sheets

• Type: Google Sheets → Append Row
• Sheet: 'Agent Action Log'
• Row fields: timestamp, platform, action, entity, old_value, new_value, rationale, confidence, validation_status

Node 11: Send Slack Notifications

• Type: Slack → Send Message
• Channel routing based on risk_level: low → #alerts, medium/high → #critical
• Message format uses Block Kit for interactive Override button

Node 12: Error Handler

• Type: Error Trigger (catches any node failures)
• Action: Send CRITICAL alert to Slack + email to MSP engineer
• Automatically pause all automation rules via API call as safety measure

A/B Test Statistical Significance Calculator

Type: skill A utility component that calculates whether an A/B test between ad variants has reached statistical significance. Prevents premature winner declarations by applying proper frequentist or Bayesian statistical methods. Called by the main agent before declaring any A/B test winner or pausing any variant.

Implementation

// Input: Two ad variants with performance data
// Output: Whether the test is statistically significant and which variant wins

function calculateSignificance(variantA, variantB, confidenceLevel = 0.95) {
  // Z-scores for common confidence levels
  const zScores = { 0.90: 1.645, 0.95: 1.96, 0.99: 2.576 };
  const zCritical = zScores[confidenceLevel] || 1.96;
  
  // Calculate conversion rates
  const rateA = variantA.conversions / variantA.impressions;
  const rateB = variantB.conversions / variantB.impressions;
  
  // Pooled standard error
  const pooledRate = (variantA.conversions + variantB.conversions) / 
                     (variantA.impressions + variantB.impressions);
  const se = Math.sqrt(pooledRate * (1 - pooledRate) * 
             (1/variantA.impressions + 1/variantB.impressions));
  
  // Z-statistic
  const zStat = Math.abs(rateA - rateB) / se;
  
  // P-value approximation (two-tailed)
  const pValue = 2 * (1 - normalCDF(zStat));
  
  // Minimum sample size check
  const minConversions = 100; // Require at least 100 conversions per variant
  const hasMinSample = variantA.conversions >= minConversions && 
                       variantB.conversions >= minConversions;
  
  // Determine winner
  let winner = null;
  if (pValue < (1 - confidenceLevel) && hasMinSample) {
    winner = rateA > rateB ? 'A' : 'B';
  }
  
  // Calculate lift
  const lift = winner === 'A' ? 
    ((rateA - rateB) / rateB * 100).toFixed(2) :
    ((rateB - rateA) / rateA * 100).toFixed(2);
  
  return {
    variant_a: {
      name: variantA.name,
      impressions: variantA.impressions,
      conversions: variantA.conversions,
      conversion_rate: (rateA * 100).toFixed(4) + '%',
      spend: variantA.spend,
      roas: variantA.revenue / variantA.spend
    },
    variant_b: {
      name: variantB.name,
      impressions: variantB.impressions,
      conversions: variantB.conversions,
      conversion_rate: (rateB * 100).toFixed(4) + '%',
      spend: variantB.spend,
      roas: variantB.revenue / variantB.spend
    },
    z_statistic: zStat.toFixed(4),
    p_value: pValue.toFixed(6),
    confidence_level: confidenceLevel,
    is_significant: pValue < (1 - confidenceLevel) && hasMinSample,
    has_minimum_sample: hasMinSample,
    winner: winner,
    lift_percent: winner ? lift + '%' : 'N/A',
    recommendation: winner ? 
      `Declare Variant ${winner} as winner with ${(confidenceLevel*100)}% confidence. ` +
      `Lift: ${lift}%. Pause the losing variant and reallocate its budget.` :
      hasMinSample ? 
        'Test has not reached statistical significance. Continue running.' :
        `Insufficient data. Need ${minConversions} conversions per variant. ` +
        `A: ${variantA.conversions}/${minConversions}, B: ${variantB.conversions}/${minConversions}.`
  };
}

// Normal CDF approximation (Abramowitz and Stegun)
function normalCDF(x) {
  const a1 = 0.254829592, a2 = -0.284496736, a3 = 1.421413741;
  const a4 = -1.453152027, a5 = 1.061405429, p = 0.3275911;
  const sign = x < 0 ? -1 : 1;
  x = Math.abs(x) / Math.sqrt(2);
  const t = 1.0 / (1.0 + p * x);
  const y = 1.0 - (((((a5*t + a4)*t) + a3)*t + a2)*t + a1)*t * Math.exp(-x*x);
  return 0.5 * (1.0 + sign * y);
}

// Usage in n8n workflow:
const variantA = {
  name: $input.first().json.variant_a_name,
  impressions: $input.first().json.variant_a_impressions,
  conversions: $input.first().json.variant_a_conversions,
  spend: $input.first().json.variant_a_spend,
  revenue: $input.first().json.variant_a_revenue
};
const variantB = {
  name: $input.first().json.variant_b_name,
  impressions: $input.first().json.variant_b_impressions,
  conversions: $input.first().json.variant_b_conversions,
  spend: $input.first().json.variant_b_spend,
  revenue: $input.first().json.variant_b_revenue
};

const result = calculateSignificance(variantA, variantB, 0.95);
return [{ json: result }];

Integration with Main Agent

The main Ad Performance Analysis Agent calls this function before any A/B test winner declaration. In the GPT-5.4 prompt, instruct: 'Before declaring any A/B test winner, pass both variants to the Statistical Significance Calculator. Only declare a winner if is_significant === true.'

Budget Guardrail Enforcement Engine

Type: workflow A standalone Make.com scenario that runs every 30 minutes and independently validates that all campaign budgets are within the defined guardrails, regardless of what the main agent has done. This is a defense-in-depth safety layer that catches edge cases where the main agent, a human, or the ad platform itself may have changed a budget outside of approved limits. If a breach is detected, it immediately pauses the offending campaign and sends a critical alert.

Implementation:

Scenario: 'Guardrail Watchdog'

• Trigger: Every 30 minutes, 24/7

Module 1: Schedule

• Type: Schedule
• Interval: 30 minutes
• Runs continuously including weekends (budgets don't sleep)

Module 2: Read Guardrails

• Type: Google Sheets → Search Rows
• Spreadsheet: [Guardrails Master Sheet]
• Sheet: 'Active Guardrails'
• Return all rows
• Output: Array of {client_name, platform, account_id, campaign_id, max_daily_budget, max_account_daily_spend, min_roas_threshold, is_special_ad_category}

Module 3: Iterator

• Type: Iterator
• Input: Guardrails array
• Iterates through each guardrail row

Module 4: Router

• Type: Router
• Route 1: platform === 'meta' → Module 5A
• Route 2: platform === 'google' → Module 5B

Module 5A: Fetch Meta Campaign Budget

• Type: HTTP Request
• Method: GET

GET https://graph.facebook.com/v19.0/act_{{account_id}}/campaigns
  ?fields=id,name,daily_budget,status,effective_status
  &filtering=[{field:'effective_status',operator:'IN',value:['ACTIVE']}]
Authorization: Bearer {{meta_system_user_token}}

Module 5B: Fetch Google Campaign Budget

• Type: HTTP Request
• Method: POST

POST https://googleads.googleapis.com/v16/customers/{{account_id}}/googleAds:search

Body:
{
  "query": "SELECT campaign.id, campaign.name, campaign_budget.amount_micros, campaign.status FROM campaign WHERE campaign.status = 'ENABLED'"
}

Module 6: Compare Against Guardrails

• Type: Set Variable + Filter
• current_daily_budget = campaign.daily_budget (Meta: in cents, divide by 100; Google: in micros, divide by 1000000)
• guardrail_max = guardrail.max_daily_budget
• is_breach = current_daily_budget > guardrail_max
• breach_amount = current_daily_budget - guardrail_max
• breach_percent = ((current_daily_budget - guardrail_max) / guardrail_max * 100)

Module 7: Filter — Only Breaches

• Type: Filter
• Condition: is_breach === true
• If no breaches, scenario ends (no action needed)

Module 8: Emergency Pause (Meta)

• Type: HTTP Request
• Method: POST

POST https://graph.facebook.com/v19.0/{{campaign_id}}
Authorization: Bearer {{meta_system_user_token}}

Body:
{
  "status": "PAUSED"
}

Module 8B: Emergency Pause (Google)

• Type: HTTP Request
• POST to Google Ads API mutate endpoint to set campaign status to PAUSED

Module 9: Log Breach

• Type: Google Sheets → Add Row
• Sheet: 'Guardrail Breaches Log'

{{timestamp}} | {{client_name}} | {{platform}} | {{campaign_name}} | {{current_daily_budget}} | {{guardrail_max}} | {{breach_percent}}% | PAUSED | WATCHDOG

Module 10: Critical Slack Alert

• Type: Slack → Send Message
• Channel: #ai-agent-critical

🚨 *GUARDRAIL BREACH DETECTED & CAMPAIGN PAUSED*

*Client:* {{client_name}}
*Platform:* {{platform}}
*Campaign:* {{campaign_name}}
*Current Daily Budget:* ${{current_daily_budget}}
*Guardrail Max:* ${{guardrail_max}}
*Breach:* +{{breach_percent}}% over limit
*Action Taken:* Campaign PAUSED by Watchdog
*Time:* {{timestamp}}

_To resume this campaign, update the guardrail in the master sheet and react with ✅_

Module 11: Email Escalation

• Type: Email → Send
• To: {{guardrail.escalation_contact}}
• Subject: [CRITICAL] Budget Guardrail Breach — {{client_name}} — {{campaign_name}}
• Body: Same content as Slack message with additional context

Error Handling

• On any module failure: Send Slack alert to #ai-agent-critical with error details
• If API rate limited: Retry with exponential backoff (Make.com built-in)
• If authentication fails: Alert MSP engineer to refresh tokens

Daily Performance Digest Generator

Type: prompt An OpenAI GPT-5.4 prompt template that generates a daily natural-language summary of all ad performance and autonomous agent activity. Sent to the agency team via Slack at 9 AM each morning. Makes complex performance data accessible to non-technical stakeholders and serves as a trust-building communication touchpoint.

Implementation

# GPT-5.4 Prompt Template (called by Make.com or n8n daily at 9 AM)

## System Prompt:
You are an expert media buying analyst creating a daily performance briefing for a marketing agency team. Your tone is professional but approachable — like a senior media buyer giving a morning standup update.

Rules:
1. Lead with the most important insight (biggest win or biggest risk)
2. Use specific numbers — never vague statements
3. Compare to yesterday and to the 7-day average
4. Highlight any autonomous agent actions taken in the last 24 hours
5. Flag any campaigns approaching guardrail limits (within 80% of max spend or below 120% of min ROAS)
6. End with 1-3 specific recommended human actions (things the agent can't/shouldn't do autonomously)
7. Use emoji sparingly but effectively for scannability
8. Keep total length under 500 words
9. Format for Slack (use *bold*, _italic_, and bullet points)

## User Prompt Template:
Generate today's performance digest based on this data:

**Date:** {{current_date}}
**Reporting Period:** Last 24 hours vs 7-day rolling average

**Campaign Performance Summary:**
{{campaign_performance_json}}

**Agent Actions Taken (Last 24h):**
{{agent_actions_json}}

**Guardrail Status:**
{{guardrail_status_json}}

**A/B Tests In Progress:**
{{ab_test_status_json}}

**Notable Events:**
- {{any_manual_overrides}}
- {{any_guardrail_breaches}}
- {{any_new_campaigns_launched}}

## Example Output:
☀️ *Morning Performance Digest — Tuesday, Jan 14*

📈 *Top Story:* Client Acme Corp's 'Summer Collection' campaign hit a 4.2x ROAS yesterday — up 38% from the 7-day avg of 3.04x. The AI agent increased its budget by 20% ($120 → $144/day) at 2:15 PM after confirming the trend held for 72 hours.

*By the Numbers (Last 24h):*
• Total spend across all clients: $3,847 (vs $3,592 7-day avg, +7.1%)
• Aggregate ROAS: 3.1x (vs 2.8x avg, +10.7%)
• Agent actions taken: 7 (4 budget adjustments, 2 ad pauses, 1 A/B winner declared)
• Guardrail breaches: 0 ✅

⚠️ *Watch List:*
• _Beta Corp 'Holiday Push'_ — ROAS dropped to 1.3x (min guardrail: 1.5x). If trend continues through today, agent will pause tomorrow. Consider refreshing creative.
• _Gamma Inc 'Lead Gen Q1'_ — Spend at 82% of daily cap. May need guardrail increase if pipeline demand warrants it.

🏆 *A/B Test Update:*
• Acme 'Hero Image v2 vs v3': v3 leading by +22% CTR. 87 conversions on v3 vs 71 on v2. Need ~30 more conversions for 95% significance. ETA: ~2 days.

🤖 *Agent Actions Detail:*
1. Paused Acme ad 'Summer_Banner_v1' — CTR 0.3% (below 0.5% threshold for 4 days)
2. Increased Beta 'Retarget_Warm' budget +15% — ROAS 5.1x sustained 5 days
3. Declared winner: Gamma 'CTA_Red' over 'CTA_Blue' — +18% conversion rate, 98.2% confidence

👉 *Recommended Human Actions:*
1. Review Beta Corp 'Holiday Push' creative — refresh needed before agent pauses
2. Discuss Gamma Inc guardrail increase with client (approaching spend cap)
3. Approve new A/B test variants for Acme Q2 campaigns (in #ai-agent-approvals)

Integration Notes

• Temperature: 0.3 (consistent but not robotic)
• Max tokens: 1000
• Model: GPT-5.4 (best balance of quality and cost)
• Estimated cost: ~$0.01-0.03 per digest (minimal token usage)
• Output goes to Slack #ai-agent-daily-digest via Make.com/n8n

Emergency Kill Switch

Type: integration A Slack slash command and Make.com webhook that immediately disables all autonomous agent operations across all platforms and clients. This is the ultimate safety mechanism — a single action that any authorized team member can execute to halt all AI-driven changes. Critical for compliance (GDPR Article 22 human override requirement) and for emergency response to agent malfunction scenarios.

Component 1: Slack Slash Command

Setup in Slack

Component 2: Make.com Kill Switch Scenario

Module 1: Webhook

• Type: Custom Webhook
• Name: 'kill-switch-trigger'
• Receives: {command: '/kill-agent', text: 'confirm', user_id, user_name, channel_id}

Module 2: Validate Confirmation

• Type: Filter
• Condition: text === 'confirm'
• If false → respond with: 'Type /kill-agent confirm to execute. This will pause ALL autonomous operations.'

Module 3: Validate Authorized User

• Type: Filter
• Condition: user_id IN [list_of_authorized_user_ids]
• If false → respond with: '❌ You are not authorized to execute the kill switch. Contact your MSP administrator.'

Module 4: Disable Optmyzr Automations

• Type: HTTP Request
• For each rule in Optmyzr, set to 'Suggest Only' via Optmyzr API
• If Optmyzr API doesn't support this, disable via browser automation with Puppeteer or use Optmyzr's bulk pause feature

Module 5: Disable Birch Rules

• Type: HTTP Request
• Birch API: Set all rules to 'Notify Only'

PATCH https://api.bfrch.com/v1/rules/{rule_id}
Body: {auto_execute: false}

Module 6: Disable n8n Agent Workflow

• Type: HTTP Request
• n8n API: Deactivate the Ad Performance Analysis Agent workflow

PATCH https://{{n8n_instance}}/api/v1/workflows/{{workflow_id}}
Headers: X-N8N-API-KEY: {{api_key}}
Body: {active: false}

Module 7: Disable Make.com Agent Scenarios (self-referential safety)

• Type: HTTP Request
• Make API: Deactivate agent scenarios (but NOT the kill switch or watchdog scenarios)

POST https://eu1.make.com/api/v2/scenarios/{{scenario_id}}/stop
Headers: Authorization: Token {{make_api_token}}

Module 8: Log Kill Switch Activation

• Type: Google Sheets → Add Row
• Sheet: 'Critical Events Log'
• Row: {{timestamp}}, KILL_SWITCH_ACTIVATED, {{user_name}}, 'All autonomous operations paused'

Module 9: Slack Confirmation

• Type: Slack → Send Message
• Channel: #ai-agent-critical

🛑 *KILL SWITCH ACTIVATED*

*Activated by:* @{{user_name}}
*Time:* {{timestamp}}
*Status:* All autonomous agent operations have been PAUSED

*What was disabled:*
✅ Optmyzr automation rules → set to Suggest Only
✅ Birch automation rules → set to Notify Only
✅ n8n Agent workflow → deactivated
✅ Make.com agent scenarios → stopped

*Still active (safety systems):*
🟢 Guardrail Watchdog (monitoring only)
🟢 Kill Switch (this system)
🟢 Logging and alerting

*To re-enable:* Use `/resume-agent confirm` or manually reactivate in each platform

Component 3: Resume Command (separate Make.com scenario)

• Slash command: /resume-agent confirm
• Reverses all Module 4–7 actions
• Requires TWO authorized users to confirm (split responsibility)
• Logs resumption event

Security Notes

• Kill switch and watchdog scenarios should be in a SEPARATE Make.com organization from agent scenarios
• Authorized users list should include MSP engineer + agency owner (minimum 2 people)
• Test kill switch monthly as part of maintenance routine
• Kill switch must work even if the optimization platform is down (direct API calls to ad platforms as fallback)

Testing & Validation

• T1 — Conversion Tracking Verification: Navigate to each client website, complete a test conversion (purchase, lead form, etc.), and verify the event appears in both Meta Events Manager (Pixel + CAPI duplicate) and Google Ads Conversion tracking within 5 minutes. Event Match Quality score should be ≥ 6.0 in Meta Events Manager.
• T2 — Platform Account Connection: In the optimization platform (Optmyzr/Birch/Madgicx/AdAmigo), verify all client ad accounts show 'Connected' status with green indicators. Pull a test performance report for the last 7 days and compare totals against native platform reporting — metrics should match within 5%.
• T3 — Guardrail Enforcement (Simulate Breach): Temporarily lower a test campaign's max daily budget guardrail to $1 below current spend. Verify the Guardrail Watchdog detects the breach within 30 minutes, pauses the campaign, sends a critical Slack alert to #ai-agent-critical, logs the event in Google Sheets, and sends an email to the escalation contact. Reset guardrail after test.
• T4 — Agent Recommendation Accuracy: In supervised mode, collect 20+ agent recommendations over 3–5 days. Have the agency's senior media buyer independently review each recommendation without seeing the agent's output. Compare: agent approval rate should be >80% (agent recommendations that the human would have also made).
• T5 — Slack Alert Routing: Trigger one action of each type (budget increase <25%, budget increase >25%, ad pause, guardrail approach warning, daily digest). Verify each arrives in the correct Slack channel (#ai-agent-alerts, #ai-agent-approvals, #ai-agent-critical, #ai-agent-daily-digest respectively) with correct formatting and interactive buttons.
• T6 — Kill Switch End-to-End: Execute /kill-agent confirm in Slack. Verify within 60 seconds: (a) all optimization platform rules switch to non-autonomous mode, (b) n8n agent workflow deactivates, (c) confirmation message appears in #ai-agent-critical with full status. Then execute /resume-agent confirm to restore. Verify all systems return to previous state.
• T7 — Dashboard Data Accuracy: Compare Looker Studio dashboard metrics for the last 7 days against native Google Ads and Meta Ads Manager reports. Verify: impressions, clicks, spend, conversions, and ROAS all match within 5% tolerance. Check that the Agent Activity Log page shows all actions from the last 48 hours.
• T8 — A/B Test Significance Calculator: Input known test data with a pre-calculated result (e.g., Variant A: 10,000 impressions, 150 conversions; Variant B: 10,000 impressions, 120 conversions). Verify the calculator returns: is_significant=true, winner=A, and a p-value < 0.05. Then test with insufficient data (< 100 conversions per variant) and verify it returns is_significant=false with an appropriate message.
• T9 — Human Override Flow: After the agent auto-pauses a test ad (in graduated autonomy), click the Override button in the Slack alert. Verify: (a) the ad is resumed/unpaused within 2 minutes, (b) automation for that campaign is paused for 24 hours, (c) the override is logged in Google Sheets with the user's name and timestamp.
• T10 — Orchestration Failover: Temporarily disable the Make.com/n8n webhook endpoint. Trigger an agent action. Verify the optimization platform still executes the action (it shouldn't depend on the middleware for core function), but that a 'webhook delivery failed' error is logged and an alert fires to the MSP via a separate monitoring channel (e.g., Make.com error notification email).
• T11 — Compliance Audit Log Completeness: Export the Google Sheets Agent Action Log for the last 7 days. Verify every row contains: timestamp, platform, action_type, entity_id, entity_name, old_value, new_value, rationale, was_auto_executed (boolean), and validation_status. No rows should have empty rationale fields.
• T12 — Multi-Platform Budget Reallocation: Set up a test scenario where one Google Ads campaign is underperforming (ROAS below threshold) and one Meta campaign is overperforming. Verify the agent recommends reducing the Google budget and increasing the Meta budget, respecting per-platform guardrails and the cross-platform budget cap.

Client Handoff

Client Handoff Checklist

Training Session (2 hours, in-person or video call)

Attendees Required: Agency owner/principal, lead media buyer(s), account managers who interact with clients

Training Topics:

Documentation Package (Leave Behind)

• Guardrails Master Spreadsheet (Google Sheets, shared with edit access for authorized personnel)
• System Architecture Diagram (visual showing all platforms, integrations, and data flows)
• Slack Channel Guide (one-pager with channel purposes and example messages)
• Kill Switch Quick Reference Card (laminated, posted near workstations)
• Optimization Platform Quick Start Guide (screenshots of key workflows)
• Compliance Checklist (quarterly self-audit checklist for GDPR/CCPA obligations)
• Escalation Contact Card (MSP phone, email, Slack, SLA tiers)
• Testing Sign-Off Sheet (signed copy from Step 10)
• Monthly Review Meeting Template (agenda for recurring optimization reviews)

Success Criteria to Review Together

Maintenance

Ongoing Maintenance Responsibilities

MSP Weekly Tasks (30–60 minutes)

• Monitor Agent Health: Check n8n/Make.com execution logs for failed runs, API errors, or rate limiting. Verify all scheduled scenarios ran successfully in the past 7 days.
• Review Guardrail Breach Log: Check for any breaches and verify they were handled correctly. Investigate root causes of repeated breaches.
• Token/Credential Check: Verify Meta System User tokens, Google OAuth refresh tokens, and API keys are valid. Meta tokens can expire; set calendar reminders for token refresh (every 60 days for short-lived tokens, or use non-expiring system user tokens).
• Platform Update Review: Check for Optmyzr/Birch/Madgicx release notes. Apply any configuration changes needed for new features or API updates.

MSP Monthly Tasks (2–3 hours)

• Monthly Performance Review Meeting with agency team (1 hour). Review: aggregate performance metrics vs. pre-implementation baseline, agent action summary (total actions, approval rate, override count), ROI analysis (time saved, ROAS improvement, budget waste reduction), guardrail adjustment discussion, and upcoming campaign strategy alignment.
• Kill Switch Test: Execute /kill-agent confirm → verify full shutdown → /resume-agent confirm → verify full restore. Document test results.
• Compliance Audit: Verify audit logs are complete, privacy policies are current, DPAs are in place with all vendors.
• Supermetrics/Connector Health: Verify data freshness in Looker Studio. Reconnect any expired data source connections.
• Cost Optimization: Review Make.com/n8n execution counts vs. plan limits. Assess OpenAI API spend and optimize prompts if costs are growing.

MSP Quarterly Tasks (4–6 hours)

• Guardrails Deep Review: Comprehensive review of all client guardrails with agency team. Adjust thresholds based on seasonal trends, new campaigns, and performance history.
• Platform Evaluation: Assess whether the current optimization platform still fits the agency's evolving needs. Review new entrants and feature updates from competitors.
• Agent Decision Quality Audit: Sample 50 agent decisions from the quarter. Have a senior media buyer evaluate each. If accuracy drops below 80%, investigate and retune rules or prompts.
• API Deprecation Check: Review Google Ads API and Meta Marketing API changelogs for upcoming deprecations. Plan migration for any endpoints being retired (Google typically gives 12 months notice).
• Security Review: Rotate API keys and tokens. Review access permissions. Remove departed employees from authorized users list.

Trigger-Based Maintenance

• Ad Platform API Update: When Google or Meta releases a new API version, test compatibility within 30 days and migrate within 90 days of old version deprecation notice.
• Optimization Platform Major Update: Test new features in a sandbox/test account before enabling on production client accounts.
• Client Onboarding/Offboarding: When the agency adds or loses a client, update guardrails sheet, connect/disconnect ad accounts, and adjust billing.
• Agent Accuracy Drop: If weekly approval rate drops below 75% or the agency team reports repeated bad recommendations, schedule an emergency tuning session to review and adjust rules, thresholds, and prompts.
• Compliance Regulation Change: Monitor GDPR enforcement actions, EU AI Act implementation timeline (August 2026/2027 milestones), and FTC guidance. Update compliance documentation within 60 days of material regulatory changes.

SLA Considerations

• P1 (Critical) — Agent malfunction causing overspend or data breach: 1-hour response, 4-hour resolution. Kill switch should be used immediately while MSP investigates.
• P2 (High) — Agent not functioning, no autonomous actions executing: 4-hour response, 1-business-day resolution. Agency operates manually during downtime.
• P3 (Medium) — Dashboard inaccuracy, missed alerts, single-account issues: 1-business-day response, 3-business-day resolution.
• P4 (Low) — Feature requests, optimization suggestions, cosmetic issues: Next monthly review meeting.

Escalation Path

Alternatives

Full SaaS Platform Only (No Custom Components)

AdAmigo.ai Maximum Autonomy (Meta-Only)

For agencies where 80%+ of ad spend is on Meta/Facebook, use AdAmigo.ai as the sole platform with its built-in AI Media Buyer running at maximum autonomy. Minimal configuration needed — the AI learns the account's patterns and makes decisions independently. Supplement with basic Slack alerting and Looker Studio dashboards.

Custom-Built Agent on n8n (Full Control Path)

Build the entire autonomous agent from scratch using n8n (self-hosted), direct ad platform API calls, OpenAI GPT-5.4 for decision intelligence, and PostgreSQL for state management. No turnkey optimization platform — the MSP builds and owns the entire stack. Provides maximum flexibility, customization, and margin (no SaaS platform fees).

Hybrid: SaaS Platform + Make.com Light Orchestration

Use a turnkey platform (Birch or Optmyzr) for core ad optimization and A/B testing, but add a lightweight Make.com layer for enhanced alerting, audit logging, and cross-system integration (CRM sync, project management updates, custom dashboards). Skip the custom LLM agent — use the platform's native intelligence.

Google Ads Performance Max + Meta Advantage+ (Platform Native AI)

Instead of third-party tools, use the ad platforms' own AI optimization features: Google Performance Max campaigns and Meta Advantage+ campaigns. These platform-native AI systems handle creative optimization, audience targeting, and budget allocation within their respective ecosystems. The MSP's role is setup, monitoring, and reporting only.