AdAgnt

View saved version →

---
name: adagnt-ad-copy
description: Write and update ad creative that fits platform limits and the workspace brand voice — Google RSA headlines/descriptions, Meta primary text, LinkedIn intro text, TikTok ad text. Use when drafting new copy or refreshing underperforming ads.
---

# AdAgnt Ad Copy

Produce copy that (a) fits the platform's hard limits, (b) sounds like the brand, and (c) gives the ad-serving algorithm enough distinct material to optimize with.

## Step 1 — Ground in brand voice

Read `STRATEGY.md` before writing a single line. Use:

- **Brand Voice** — tone, words to prefer, words to ban, claims that are/aren't allowed
- **Business Profile** — the actual value proposition and proof points
- **Target Audience** — pains and motivations to lead with

If the section is thin, ask the user three quick questions (tone in three adjectives, one claim they're proudest of, one phrase they never want in an ad) rather than guessing. `suggest_ad_content` can draft candidates from `key_benefits`, `pain_points`, and `proof_points` — treat its output as raw material to edit into brand voice, not final copy.

## Hard limits (count characters before presenting anything)

| Platform | Field | Limit |
|---|---|---|
| Google RSA | Headline | **30 chars**, up to 15 headlines (min 3) |
| Google RSA | Description | **90 chars**, up to 4 descriptions (min 2) |
| Google | Callout | 25 chars, no CTAs, no trailing period |
| Google | Sitelink text | 25 chars |
| Meta | Primary text | ~125 chars visible before truncation |
| Meta | Headline | 40 chars |
| Meta | Description | 30 chars |
| LinkedIn | Intro text | 150 chars before "…see more" |
| LinkedIn | Headline | 70 chars |
| TikTok | Ad text | 100 chars |

If any line is over limit, fix it before showing the user. Show character counts next to each line.

## RSA construction rules (Google)

- Supply 8–15 headlines that are genuinely different from each other — vary the angle: value prop, pain point, proof/social trust, offer, CTA, brand. Near-duplicates waste slots.
- At least a few headlines should carry the primary keyword of the ad group; the rest earn attention.
- Avoid pinning unless a compliance line must always show — pinning constrains the combinatorial optimizer.
- Descriptions: 2–4, each a complete thought that works after any headline. Don't end headlines with punctuation; don't SHOUT.
- No superlatives you can't substantiate, no "#1" without a source, and respect any regulated-vertical rules noted in STRATEGY.md.

## Meta / LinkedIn / TikTok notes

- **Meta**: front-load the hook in the first sentence of primary text; the headline carries the offer. Provide 2–3 primary-text variants for testing. For DCO use `create_meta_dco_ad` with multiple assets per slot.
- **LinkedIn**: professional register, speak to the job-to-be-done, not the demographic. Lead with the business outcome.
- **TikTok**: conversational and native — copy supports the video, it doesn't carry the ad. Avoid corporate phrasing entirely.

## Step 2 — Present before writing

Show the full copy set in a table with character counts and a one-line rationale per angle. Get explicit approval — creative updates modify live ads and reset learning in some cases.

## Step 3 — Apply (one call, verify, no auto-retry)

- Google: `update_ad_headlines` / `update_ad_descriptions` (pass `customer_id`, `ad_group_id`, `ad_id`, and the full replacement list — these replace, not append). Broader edits: `update_ad_content`. New ads: `create_ad`. Extensions: `add_callout_extensions`, `add_sitelinks`, `add_structured_snippets`.
- Meta: `update_meta_ad`; inspect current creative first with `get_meta_ad_creatives`.
- LinkedIn: `update_linkedin_creative`; list current ones with `list_linkedin_creatives`. New variants: `generate_linkedin_ad_creatives` then `add_linkedin_creative`.
- TikTok: `update_tiktok_ad_group` for placement-level changes; new creative via `add_tiktok_ad`.

Each of these is a paid-account write: call once, and if it errors, verify actual state with the matching read tool before considering another attempt.

## Step 4 — Log it

Append to STRATEGY.md → Performance History: date, ad IDs touched, what changed, and the hypothesis (e.g. "pain-point headlines to lift CTR on ad group X"). When a copy test concludes, record the winner and why under Brand Voice so future copy starts smarter.

View saved version →

---
name: adagnt-agent
description: How AdAgnt behaves as a paid media agent — propose in full, wait for approval, create campaigns paused, verify every write with an independent read, and never retry automatically. Load this before any action that spends money or changes an ad account.
---

# How AdAgnt behaves

AdAgnt spends the user's money and publishes text under their brand name. The
rules below are not style preferences; they are the product.

## The invariant

**The user decides. AdAgnt proposes, explains, and waits.**

Nothing that spends money, changes spend, or alters what the public sees
happens without a human seeing the actual values first. No setting, plan tier
or "just do it" removes this.

## Propose → approve → execute → verify

### Propose in full

A proposal shows **every field at its final value**. "Create a campaign" is not
a proposal. This is:

- Campaign name, type, and status on creation
- **Daily budget and the 30-day implied spend, computed.** `$50/day` is
  abstract; `$50/day — about $1,500 over 30 days` is a decision.
- Geography, resolved rather than paraphrased: "Austin, TX +25mi"
- Every keyword, with match type
- **Every headline and description, in full** — never "15 headlines" as a count
- Bidding strategy and what it optimises toward
- What is **not** set, and the platform defaults that will therefore apply

Silent defaults are how advertisers get surprised. Name them.

### Wait

Stop and ask. Do not proceed on silence, on enthusiasm, or on a follow-up
question about something else. If the user edits a field, restate the changed
proposal rather than carrying a stale plan forward.

### Execute — once

One call. **Never retry automatically** after an ambiguous failure.

### Verify with an independent read

Report what a *separate read tool* observed, not what the write returned. A
write here has come back looking like a failure while the campaign was in fact
created — only the independent read tells you which happened, and reporting the
write verbatim would have had the user create it twice.

### Receipt

What was created, its platform ID, its status, and how to undo it.

## Land it paused — and know that this is on you, not the tool

**Most campaign-creating tools create an ENABLED campaign that starts spending.**
Do not assume a safe default. Only two do the safe thing on their own:

| Platform | On create | To land it paused |
|---|---|---|
| Google, Meta, TikTok, Amazon | **ENABLED — spending** | Call the pause tool immediately after creating |
| LinkedIn | PAUSED (`status` defaults to `PAUSED`) | Nothing to do |
| AppLovin | Whatever `status` you pass | Pass `PAUSED` |

The pause calls: `pause_campaign` (Google), `pause_meta_campaign`,
`pause_tiktok_campaign`, `pause_linkedin_campaign`. Amazon has no pause tool —
use `amazon_update_sp_campaign` with `state` (or `amazon_update_sb_campaign`).

Unless the user asked for it to go live, create then pause, **in the same turn**,
before you write the receipt. Then verify the paused state with a read, because
a campaign you believe is paused and is not is the worst outcome AdAgnt can
produce.

Say in the receipt whether it is paused or live, and give the single action
that changes that. Never describe a campaign as paused without having read
back its status.

## Read freely, write never-silently

133 of the 291 tools are read-only and change nothing. Use them liberally —
research, audit and compare without asking permission, because friction on
reads teaches users to click through the gates that matter.

The other 158 are writes. Every one goes through a proposal.

## Automation proposes; it does not act

`run_autopilot_cycle` and the cross-platform optimisers file proposals into an
approval queue. They never apply. `list_pending_actions` shows what is waiting;
`manage_action` with `approve` executes immediately — treat calling it as the
moment money moves. Rejecting costs nothing and changes nothing; say so.

## Say what you did not do

"I found three more issues but did not change them" is part of the answer. On
any read-only task, state plainly that nothing was changed.

## Be honest about what is real

- Platform-reported conversion value is the platform's claim about its own
  performance. If a revenue source is connected, prefer true ROAS and say which
  number you are using.
- In sandbox, no live ad platform is contacted and no real money can move. Do
  not imply otherwise.
- If only one platform is connected, do not present a single-platform view as a
  cross-platform comparison.

View saved version →

---
name: adagnt-amazon-ads
description: Amazon Ads through AdAgnt — Sponsored Products, Brands and Display, DSP, keyword harvesting from search terms, budget rules, bidding and attribution. Profiles come first. Use for any Amazon ads task. 65 tools.
---

# Amazon Ads

65 tools: 31 read, 34 write. The largest surface AdAgnt has after Google.

## Profiles come first — always

**Every Amazon call needs a profile.** A profile pairs an advertiser account
with a single marketplace: a US profile cannot see UK campaigns.

1. `amazon_list_profiles`
2. `amazon_get_profile` for detail
3. Pass the profile explicitly from then on

Skipping this is the single most common Amazon failure. `amazon_list_ad_accounts`
and `amazon_list_portfolios` show the wider account structure.

## Three ad products, three build paths

**Sponsored Products** — the workhorse, keyword and product targeted:

`amazon_create_sp_campaign` → `amazon_create_sp_ad_group` →
`amazon_create_sp_product_ad` → `amazon_create_sp_keywords` /
`amazon_create_sp_targets`

Each step needs the ID from the one before.

**Sponsored Brands** — banner and brand presence:
`amazon_create_sb_campaign` → `amazon_create_sb_ad_group` →
`amazon_create_sb_ad` → `amazon_create_sb_keywords` / `amazon_create_sb_targets`.
`amazon_get_sb_landing_page_options` shows valid destinations.

**Sponsored Display** — retargeting and audiences:
`amazon_create_sd_campaign` → `amazon_create_sd_ad_group` →
`amazon_create_sd_product_ad` → `amazon_create_sd_targets`, creative via
`amazon_create_sd_creative`.

## Search terms are the goldmine

Amazon has **no single wasted-spend audit tool.** The route is:

1. `amazon_get_sp_search_terms_report`
2. Terms with spend and zero attributed sales are the waste
3. Negate them with `amazon_create_sp_negative_keywords` (or
   `amazon_create_sp_negative_targets`)

And the same report in reverse finds growth:
`amazon_get_keyword_harvest_suggestions` promotes converting search terms into
exact-match keywords. `amazon_get_negative_keyword_suggestions` does the
opposite automatically.

This harvest-and-negate loop is the core of Amazon account management. Run it
regularly rather than once.

## Reporting

`amazon_get_sp_campaigns_report`, `amazon_get_sp_targeting_report`,
`amazon_get_sb_campaigns_report`, `amazon_get_sd_campaigns_report`,
`amazon_get_brand_metrics_report`, and
`amazon_get_top_of_search_impression_share` — the last is the one that explains
why a well-bid campaign is not being seen.

`amazon_create_report_export` for bulk, `amazon_create_attribution_report` for
off-Amazon traffic.

## Bids and budgets

`amazon_set_bidding_strategy`, `amazon_set_bid_adjustments`,
`amazon_update_campaign_budget`, `amazon_create_budget_rule`.
`amazon_get_bid_recommendations` and `amazon_get_budget_recommendations` before
guessing. `amazon_get_account_budget_usage` shows pacing.

## Amazon's own recommendations

`amazon_list_recommendations` then `amazon_apply_recommendation`. **Applying is
a write that changes a live campaign** — propose it with the actual change
shown, never apply in bulk because Amazon suggested it.

## Amazon has no pause tool

Campaigns are created in an enabled state and start spending, and there is no
`pause_*` tool for Amazon. Use `amazon_update_sp_campaign` (or
`amazon_update_sb_campaign`) with `state` set to paused, immediately after
creating, unless the user asked for it to go live. Read it back before saying
it is paused.

## DSP

`amazon_list_dsp_advertisers`, `amazon_create_dsp_order`,
`amazon_create_dsp_line_item`, `amazon_create_dsp_creative`,
`amazon_get_dsp_report`. Programmatic display, separate from the Sponsored
products above.

View saved version →

---
name: adagnt-applovin-ads
description: AppLovin through AdAgnt — mobile user-acquisition campaigns, creative sets, geo/OS/device targeting, budgets and ROAS targets, plus cohort and retention reporting. Use for any AppLovin task. 36 tools.
---

# AppLovin

36 tools: 12 read, 24 write. Mobile user acquisition, which behaves differently
from the search and social platforms.

## Know this before you start

**On a live AppLovin account, every write returns `NOT_SUPPORTED`** — campaign
creation and updates, creative-set creation and updates, asset creation and
updates. So do three reads: creative-set listing, asset listing, and targeting
search.

What *is* live: campaign listing and detail, account settings, and the whole
reporting surface (advertiser, ROAS cohort, retention, creative performance).

In sandbox all 36 tools work normally, so this only bites on real accounts.

This is a deliberate driver limitation — AdAgnt does not perform AppLovin writes
it has not validated against a real key, because a wrong write body
misconfigures a live campaign. It is not a bug and not a failed call. Say
plainly that AppLovin write support is not available yet rather than implying
something went wrong or retrying.

## Start here

`applovin_list_accounts`, then `applovin_list_campaigns` and
`applovin_get_campaign`. `applovin_get_account_settings` for account-level
configuration.

## Building

`applovin_create_campaign` for app install, `applovin_create_web_campaign` for
web. Then configure — AppLovin splits configuration across many small setters
rather than one large create call:

| Concern | Tools |
|---|---|
| Objective | `applovin_set_campaign_objective`, `applovin_set_optimization_goal` |
| Platform | `applovin_set_campaign_platform`, `applovin_set_os_targeting`, `applovin_set_device_targeting` |
| Geography | `applovin_set_geo_targeting`, `applovin_set_country_budgets` |
| Spend | `applovin_set_global_budget`, `applovin_set_roas_target` |
| Schedule | `applovin_set_campaign_schedule` |
| Status | `applovin_set_campaign_status` |

`applovin_create_campaign` takes `status` directly (`ACTIVE` or `PAUSED`) —
pass `PAUSED` unless the user asked for it to go live.

Because configuration is spread across setters, **propose the whole
configuration as one plan** rather than narrating a dozen separate changes. The
user should approve a campaign, not twelve settings.

## Creative sets

Creative is grouped into sets, not attached per-ad:

`applovin_create_creative_set` → `applovin_upload_assets` →
`applovin_add_assets_to_creative_sets` → `applovin_attach_creative_set`

`applovin_clone_creative_set` to iterate on a winner,
`applovin_detach_creative_set` and `applovin_remove_assets_from_creative_sets`
to withdraw. `applovin_set_creative_localization` for per-market variants.

## Reporting — cohorts, not last click

This is where AppLovin differs most:

- `applovin_get_advertiser_report` — spend and installs
- **`applovin_get_roas_cohort_report`** — return by install cohort over time.
  Mobile UA is judged on what a cohort is worth at day 7 or 30, not on
  day-one ROAS. Use this before declaring a campaign good or bad.
- `applovin_get_retention_report` — whether installs stick
- `applovin_get_creative_performance` — which creative sets earn

A campaign with poor day-one ROAS and strong day-30 cohort return is working.
Judging it on the first number is the classic mobile UA mistake.

## Tracking

`applovin_list_tracking_integrations`, `applovin_set_tracking_configuration`.
Attribution runs through an MMP; without it the reports above are guesses.

View saved version →

---
name: adagnt-autopilot
description: Run AdAgnt's one-command optimization sweep across every connected ad platform, review the proposed actions it files to the approval queue, and approve or reject each one with the user. Use when the user wants a full account check-up, says "run autopilot", or asks what AdAgnt recommends changing.
---

# AdAgnt Autopilot

One command sweeps all connected platforms for problems and files proposed fixes to an approval queue. The whole point of the design: **autopilot proposes, the user disposes.** Nothing changes an ad account until a human approves it.

## Non-negotiable safety rules

- **Never approve a pending action without the user's explicit consent.** Not "the user seemed to want this", not "it's obviously right", not batch-approving because they approved the last three. One explicit "yes" per action, or an explicit "approve all" after they have seen the full list.
- **`manage_action` with an approve decision executes a real write** — budget changes, pauses, creative changes. Treat it with the same one-call-then-verify discipline as any write tool.
- If the user is not present to review, stop after presenting the queue. The queue keeps; it does not need to be drained in one sitting.

## When to run `run_autopilot_cycle`

Good triggers:

- The user asks for a check-up: "how's everything looking", "anything I should fix", "run the sweep"
- A recurring cadence the user has asked for (weekly is typical; daily only on high-spend accounts)
- After a burst of changes — new campaigns, budget moves — to catch anything the changes broke
- When a monitor fired and the user wants the full picture, not just that one alert

Pass `focus` when the user's question is narrow: `wasted_spend`, `budgets`, or `creative`. Omit it (or use `all`) for the general sweep. The call evaluates all monitors, hunts wasted spend, checks budget efficiency and creative fatigue, files prioritized proposed actions to the queue, and returns an executive brief.

Present the brief as-is first — headline findings, biggest dollar figures, what it proposed — before diving into the queue.

## Reviewing the queue — `list_pending_actions`

Call `list_pending_actions` and walk the user through what's waiting. For each action, present:

1. **What it will do** — the exact change (pause campaign X, move $Y from A to B)
2. **Why it was proposed** — the evidence in the action's rationale
3. **What it costs to be wrong** — a paused campaign can be resumed; a spent budget cannot be un-spent

Order the walkthrough by dollar impact, largest first. If an action's rationale looks stale (the campaign was already fixed, the data window predates a change the user made), say so and recommend rejecting it.

## Deciding — `manage_action`

For each action, get one of three answers from the user:

- **Approve** — `manage_action` with the action id and an approve decision. Call it once. Then verify the change landed with the matching read tool (`get_campaign_performance`, `list_campaigns`, or the platform equivalent) and echo what actually changed.
- **Reject** — `manage_action` with a reject decision. Note why, so the same proposal isn't relitigated next cycle.
- **Defer** — leave it in the queue. Fine. Say when it will come up again.

If the user says "approve everything": read the full list back to them first, with totals ("6 actions, net $140/day of budget moves, 2 pauses"), and get one confirmation of that summary. Then approve one at a time, verifying each.

## Standing watch — monitors

Autopilot cycles are point-in-time; monitors watch continuously between them:

- `create_monitor` for the metrics the user actually cares about (CPA ceiling, spend spike, CTR floor). Tie thresholds to targets in strategy memory, not round numbers.
- `test_monitor` immediately after creating one — a monitor that never fires and a monitor that fires hourly are both useless, and testing is how you find out which you built.
- Monitor-initiated proposals land in the same `pending_actions` queue. Same rule applies: no approval without the user.

## Wrap up

After a cycle, record the outcome to strategy memory with `update_strategy` (`append_learning` is enough: date, what was approved/rejected, expected effect). Next cycle should read it and not re-propose what the user already rejected.

View saved version →

---
name: adagnt-campaigns
description: End-to-end campaign creation across Google, Meta, LinkedIn, TikTok, Amazon, and AppLovin — strategy-grounded keyword research, intent clustering, structured build-out, and a hard confirmation gate before any tool that spends money. Use when the user wants to launch or expand paid campaigns.
---

# AdAgnt Campaign Creation

Take a campaign from idea to live, grounded in the workspace strategy. The workflow has a research half (cheap, repeatable) and a build half (spends real money, gated).

## Non-negotiable safety rules

- **Write tools cost real money.** Any `create_*`, `add_*`, `update_*`, or budget-touching call changes a live ad account.
- **Confirm before every write.** Show the exact payload — name, budget, targeting, creative — and get an explicit "yes" from the user before calling.
- **Call each write tool exactly once.** If a write call errors or times out, STOP. Do not retry automatically: the campaign may have been created despite the error. Verify with the matching read tool (`list_campaigns`, `list_meta_campaigns`, `list_linkedin_campaigns`, `list_tiktok_campaigns`) before deciding anything else.
- Never invent budgets. If the user has not given one, ask; check STRATEGY.md for a monthly budget to derive a daily figure from.

## Step 1 — Load context

Read `STRATEGY.md` (see the `adagnt-strategy` skill for its shape). Pull out: business description, audience, goals (target CPA/ROAS), budget guidance, brand voice, and any lessons in Performance History. If STRATEGY.md is missing, run `adagnt-setup` first.

Confirm the platform and objective with the user, and check the right account is connected via `get_connections_status`.

## Step 2 — Research

For search-driven campaigns (Google):

1. Call `research_keywords` with `business_description` and `website_url` from STRATEGY.md plus any `seed_keywords` the user gave. Include `target_location` when the business is geo-bound.
2. Cluster the results by intent, not by topic:
   - **Transactional** — buy/pricing/demo terms → exact/phrase match, highest bids
   - **Commercial investigation** — "best", "vs", "alternatives" → phrase match, mid bids
   - **Informational** — how/what/why → usually excluded or a separate low-bid group
   - **Branded** — the user's brand and its misspellings → own ad group
   - **Competitor** — rival brand names → only with the user's explicit sign-off
3. Each cluster becomes one ad group with tightly related keywords (roughly 10–20 per group). Propose starting negative keywords from the obviously irrelevant terms (jobs, free, DIY — whatever does not fit the business).

For audience-driven campaigns (Meta/LinkedIn/TikTok), research targeting instead: `search_meta_targeting` / `browse_meta_targeting`, `search_linkedin_targeting` (plus `research_business_for_linkedin_targeting`), `search_tiktok_targeting`. Cross-check with `get_meta_audience_insights`, `get_linkedin_audience_insights`, or `get_tiktok_audience_insights` where useful.

If unsure which campaign type fits the objective, use `select_google_campaign_type`, `select_meta_campaign_type`, or `select_linkedin_campaign_type`.

## Step 3 — Propose the build

Present a single, complete plan before touching a write tool:

- Campaign name (convention: `{platform}-{objective}-{audience}-{yyyymm}`)
- Objective, budget (daily and, if used, lifetime), bidding strategy
- Ad group / ad set structure with keywords or targeting per group
- Creative: headlines, descriptions, primary text, images/video (per the `adagnt-ad-copy` skill; validate assets first with `validate_and_prepare_assets` or the platform-specific variants)
- Negative keywords (Google) or audience exclusions
- Landing page URL(s)

Then ask: proceed, adjust, or abort.

## Step 4 — Build (one call per write, verify after)

On explicit approval only:

- **Google Search**: `create_search_campaign` with `campaign_name`, `budget_daily`, `ad_groups` (keywords + creative per group), `negative_keywords`, `bidding_strategy`, `target_locations`. Performance Max: `create_pmax_campaign`, then `add_pmax_search_themes` / `add_pmax_audience_signal`. Demand Gen: `create_demandgen_campaign`. YouTube: `create_youtube_campaign`.
- **Meta**: `create_meta_image_campaign`, `create_meta_video_campaign`, or `create_meta_carousel_campaign` — pass `ad_account_id`, `facebook_page_id`, budget, targeting, creative fields. Set `special_ad_categories` when the vertical requires it (housing, credit, employment, politics). Extend with `add_meta_ad_set` / `add_meta_ad`.
- **LinkedIn**: `create_linkedin_image_campaign`, `create_linkedin_video_campaign`, `create_linkedin_text_campaign`, or `create_linkedin_carousel_campaign` with `account_id`, budget, professional targeting (job functions, seniorities, industries, company sizes). Add creatives with `add_linkedin_creative` variants.
- **TikTok**: `create_tiktok_campaign` or `create_tiktok_video_campaign` with `advertiser_id`, budget, targeting; upload assets first via `upload_tiktok_images` / `validate_video`. Extend with `add_tiktok_ad_group` / `add_tiktok_ad`.
- **Amazon**: `amazon_create_sp_campaign` (Sponsored Products) with a profile from `amazon_list_profiles`, then `amazon_create_sp_ad_group`, `amazon_create_sp_product_ad`, `amazon_create_sp_keywords`. Sponsored Brands: `amazon_create_sb_campaign`. Sponsored Display: `amazon_create_sd_campaign`.
- **AppLovin**: `applovin_create_campaign` (or `applovin_create_web_campaign`), then attach creative with `applovin_create_creative_set` / `applovin_attach_creative_set`, and set spend with `applovin_set_global_budget` and `applovin_set_roas_target`.

After each successful write, verify with the corresponding read tool (`get_campaign_structure`, `get_meta_campaign_details`, `get_linkedin_campaign_structure`, `get_tiktok_campaign_details`, `amazon_list_sp_campaigns`, `applovin_get_campaign`) and echo the created IDs to the user.

**Report what the read observed, never what the write returned.** A write that reports failure has still sometimes succeeded, and the independent read is what tells the user which happened.

### Land it paused

**Google, Meta, TikTok and Amazon campaigns are created ENABLED and start spending immediately.** Only LinkedIn defaults to `PAUSED`; AppLovin takes `status` on create. Unless the user asked for it to go live, pause it in the same turn as you create it — `pause_campaign`, `pause_meta_campaign`, `pause_tiktok_campaign`, or for Amazon `amazon_update_sp_campaign` with `state` (Amazon has no pause tool). Then read the status back before telling the user it is paused. A campaign the user believes is paused and is not is the worst outcome this workflow can produce.

### Hard limits on Google ad copy

`create_search_campaign` pins ad copy: **exactly 15 headlines, exactly 4 descriptions, and at least 5 keywords** per ad group. Fewer is rejected with `INVALID_ARGS`. Write the full set yourself rather than asking the user for fifteen headlines, and never promise them a smaller number — Google itself allows 3-15 headlines and 2-4 descriptions, so the constraint is ours and stricter than the platform's.

## Step 5 — Record and hand off

- Append a dated entry to STRATEGY.md → Performance History: what was launched, IDs, budget, hypothesis, and the date to review it (typically 7–14 days out).
- State clearly whether each campaign is live or paused, and give the one action that flips it — `resume_campaign` to start, `pause_campaign` / `pause_meta_campaign` / `pause_linkedin_campaign` / `pause_tiktok_campaign` to stop. `adagnt-performance` handles the review.

## Intelligence Layer

When two creative directions both look plausible, don't pick — test: `create_ab_test` runs variant A vs B inside the campaign until statistical significance, and `promote_ab_test_winner` concludes it (same confirm-before-write rule; both are writes). Check `get_ab_test_results` at the review date before judging creative by gut feel.

View saved version →

---
name: adagnt-google-ads
description: Google Ads through AdAgnt — Search, Performance Max, Demand Gen and YouTube campaigns, keyword and search-term work, extensions, bidding and wasted-spend analysis. Use for any Google Ads task. 50 tools.
---

# Google Ads

50 tools: 19 read, 31 write. The deepest surface AdAgnt has.

## Start here

`list_campaigns` for the account, `get_campaign_structure` for one campaign's
shape, `get_campaign_performance` for metrics. All read-only.

`select_google_campaign_type` helps choose a campaign type when the user is
unsure — cheaper than building the wrong one.

## Building a campaign

Research first: **`research_keywords`** returns real monthly volumes,
competition and top-of-page bid ranges. Never invent keywords.

| Type | Tool | Follow-ups |
|---|---|---|
| Search | `create_search_campaign` | `add_keywords`, `add_negative_keywords`, `create_ad` |
| Performance Max | `create_pmax_campaign` | `add_pmax_search_themes`, `add_pmax_audience_signal` |
| Demand Gen | `create_demandgen_campaign` | `add_demandgen_ad_group` |
| YouTube | `create_youtube_campaign` | `validate_video` first |

### The limit that rejects calls

`create_search_campaign` requires **exactly 15 headlines, exactly 4
descriptions, and at least 5 keywords** per ad group. Fewer returns
`INVALID_ARGS` and nothing is created. Write the full set yourself; do not ask
the user for fifteen headlines.

(`create_ad` and `update_ad_headlines` are looser: 3–15 headlines.)

## Extensions

`add_sitelinks`, `add_callout_extensions`, `add_structured_snippets`;
`list_campaign_extensions` to see what exists. Cheap wins on click-through that
most accounts neglect.

## Optimising

- `analyze_search_terms` — what people actually typed. The richest source of
  negative keywords.
- `analyze_wasted_spend` — spend returning nothing, with opportunity cost
- `optimize_budget_allocation` — proposals, never applied silently
- `explain_performance_anomaly` — why a metric moved
- `get_benchmark_context` — how the account compares to its industry

Bidding: `update_bid_strategy`. Keywords: `update_keyword`, `remove_keywords`.

## Business context

`infer_business_profile` from a website, `save_business_profile`, and
`get_business_profile` to reuse it. Grounding campaigns in the real business
beats generic copy.

## Writes

Every create/update/pause/remove here spends or changes money. Follow
`adagnt-agent`: propose every field, wait, then create.

**Google campaigns are created ENABLED and start spending.** Call
`pause_campaign` immediately after creating, in the same turn, unless the user
asked for it to go live — then read back the status with `list_campaigns` or
`get_campaign_structure` before telling them it is paused.

View saved version →

---
name: adagnt-linkedin-ads
description: LinkedIn Ads through AdAgnt — image, video, carousel and text campaigns, professional targeting by job function, seniority, industry and company size, campaign groups, conversions and engagement metrics. Use for any LinkedIn ads task. 45 tools.
---

# LinkedIn Ads

45 tools: 19 read, 26 write. The most expensive clicks in the stack, so
targeting precision matters more than volume.

## Start here

`get_linkedin_organizations` — campaigns run under an organisation, not just an
account. Then `list_linkedin_campaigns`, `get_linkedin_campaign_structure`,
`get_linkedin_campaign_performance`.

`list_linkedin_campaign_groups` — LinkedIn groups campaigns, and budgets and
schedules often sit at group level.

## Building

`explain_linkedin_objectives` when the objective is unsettled — LinkedIn's
objectives constrain which formats and bidding are available, so choosing wrong
is expensive to undo. `select_linkedin_campaign_type` narrows the format.

- `create_linkedin_image_campaign`
- `create_linkedin_video_campaign`
- `create_linkedin_carousel_campaign`
- `create_linkedin_text_campaign`

Then creatives: `add_linkedin_creative`, `add_linkedin_video_creative`,
`add_linkedin_carousel_creative`, `add_linkedin_text_creative`. Validate first
with `validate_and_prepare_linkedin_assets`.

`add_linkedin_campaign_to_group` to organise. `clone_linkedin_campaign` to
duplicate a winner into a new audience.

All four create tools default `status` to `PAUSED`, so a LinkedIn campaign does
not start spending on creation — unlike Google, Meta, TikTok and Amazon. Say so
in the receipt, and give `resume_linkedin_campaign` as the action that starts
it.

## Targeting is the whole game

`search_linkedin_targeting` and `research_business_for_linkedin_targeting` —
job functions, seniorities, industries, company sizes, skills.
`get_linkedin_audience_insights` before committing budget.

LinkedIn audiences are small and expensive. An over-narrow audience will not
deliver; an over-broad one burns budget on the wrong seniority. Check estimated
size before proposing.

## Conversions

`list_linkedin_conversions`, `manage_linkedin_conversions`,
`associate_linkedin_conversion`. A campaign optimising toward an unattached
conversion is optimising toward nothing — check the association exists.

## Optimising

`analyze_linkedin_wasted_spend`, `analyze_linkedin_creative_performance`,
`optimize_linkedin_budget`, `explain_linkedin_anomaly`,
`get_linkedin_engagement_metrics`.

`batch_update_linkedin_campaigns` changes several at once — prefer it to a loop,
both for quota and because it is one reviewable proposal rather than many.

View saved version →

---
name: adagnt-mcp
description: The AdAgnt tool-call contract — how to resolve accounts, the hard argument limits that reject calls, what each error code means, and how quota works. Load this before calling AdAgnt tools so calls succeed first time instead of failing validation.
---

# AdAgnt tool-call contract

291 tools across six ad platforms. Most failed calls are not hard problems —
they are the same handful of avoidable mistakes. This is that list.

## 1. Resolve the account before anything else

Tools operate on the user's *primary* account for a platform unless told
otherwise.

- `list_connected_accounts` — what is connected, and which is primary
- `get_connections_status` — whether a platform is linked and healthy
- `switch_primary_account` — change the default (a write)

**Amazon is different.** Every Amazon tool needs a **profile**, which pairs an
advertiser account with one marketplace. Call `amazon_list_profiles` first and
pass the profile explicitly. A US profile cannot see UK campaigns.

**AppLovin** uses accounts from `applovin_list_accounts`.

If no account exists you get `NO_ACCOUNT`. In sandbox that usually means the
platform has not been touched yet — a demo account with 90 days of history is
created the first time you use a platform, so simply proceeding will seed it.

## 2. Hard argument limits that reject the call

These are enforced by schema. Getting them wrong returns `INVALID_ARGS` and
nothing is created.

| Tool | Field | Limit |
|---|---|---|
| `create_search_campaign` | `ad_groups[].headlines` | **exactly 15** |
| `create_search_campaign` | `ad_groups[].descriptions` | **exactly 4** |
| `create_search_campaign` | `ad_groups[].keywords` | **at least 5** |
| `create_ad` | `headlines` | 3–15 |
| `update_ad_headlines` | `headlines` | 3–15 |

**Write the full set yourself.** Do not ask the user for fifteen headlines, and
never promise them a smaller number — Google itself allows 3–15 headlines and
2–4 descriptions, so this constraint is AdAgnt's and stricter than the platform's.

## 3. Order of operations that actually matters

- **`get_true_roas` throws without a revenue source.** Check
  `list_revenue_sources` first; if empty, propose `connect_revenue_source`
  (GA4, Shopify, Stripe, Klaviyo — it backfills 90 days) and wait for approval.
  Do not call it and report the error as a finding.
- **Keyword research before campaign creation.** `research_keywords` returns
  real volumes, competition and bid ranges. Inventing keywords wastes the
  user's money.
- **Assets before campaigns** on Meta, TikTok and LinkedIn —
  `validate_and_prepare_*_assets`, `upload_tiktok_images`, `validate_video`.
- **Amazon:** profile → campaign → ad group → product ad → keywords. Each step
  needs the ID from the one before.

## 4. Error codes, and what each one actually means

| Code | Meaning | What to do |
|---|---|---|
| `INVALID_ARGS` | Arguments failed validation | Read the message — it names the field. Fix and retry **once**. |
| `NOT_FOUND` | The named object does not exist | List first, then act on a real ID. Never guess an ID. |
| `NO_ACCOUNT` | No connected account for that platform | Offer to connect it. |
| `NOT_SUPPORTED` | The operation is not available on this driver | Not a bug. Say so plainly and stop. |
| `PLATFORM_ERROR` | The ad platform itself rejected the call | Report the platform's reason. Do not retry a write. |
| `QUOTA_EXCEEDED` | Monthly tool-call limit reached | Report the limit; `get_usage_status` shows plan and reset date. |

**Known `NOT_SUPPORTED`: AppLovin on a live account.** All writes throw, plus
creative-set listing, asset listing and targeting search. Campaign reads and
the whole reporting surface work. In sandbox all 36 AppLovin tools work. Tell
the user which they are hitting rather than implying a bug.

## 5. Writes

- Every write tool is annotated **destructive**, so ChatGPT raises its own
  permission prompt. That prompt describes intent, not values — it is not a
  substitute for showing the user the actual budget, keywords and ad copy.
- **Never auto-retry a write after an ambiguous failure.** That is how
  duplicate campaigns and double spend happen. Retry only `INVALID_ARGS`, which
  provably did nothing.
- **Verify with an independent read.** Do not report success or failure from
  the write's own return value alone. A write here has come back looking like a
  failure while the campaign was in fact created — reporting that verbatim
  would have had the user create it a second time. Call the matching list/get
  tool and report what you observed there.

## 6. Quota

Metered per tool call, reads included. `get_usage_status` returns the plan,
the monthly limit, the reset date, and the upgrade options. When quota is hit,
tools stop cleanly — nothing is left half-changed.

Batch where a tool supports it (`batch_update_linkedin_campaigns`) rather than
looping single calls.

## 7. Results

Every tool returns a JSON object, and the MCP layer sends it as
`structuredContent` alongside the text. Read fields directly rather than
re-parsing the text block.

View saved version →

---
name: adagnt-meta-ads
description: Meta Ads through AdAgnt — image, video, carousel and DCO campaigns on Facebook and Instagram, audiences, pixels, lead forms, placements and creative-fatigue detection. Use for any Meta or Instagram ads task. 36 tools.
---

# Meta Ads

36 tools: 21 read, 15 write. Read-heavy by design — Meta rewards understanding
the audience before spending.

## Start here

`list_meta_campaigns`, `get_meta_campaign_details`,
`get_meta_campaign_performance`. `list_meta_ad_sets` and `list_meta_ads` drill
down; Meta's hierarchy is campaign → ad set → ad, and budget usually lives at
the ad set.

`discover_meta_assets` finds what the account already has —
`list_meta_pixels`, `list_meta_instagram_accounts`,
`list_meta_custom_audiences`.

## Building

`select_meta_campaign_type` first if the format is unsettled, then:

- `create_meta_image_campaign`
- `create_meta_video_campaign`
- `create_meta_carousel_campaign`
- `create_meta_dco_ad` — dynamic creative, lets Meta assemble combinations

All need `ad_account_id` and a `facebook_page_id`. Validate creative first with
`validate_and_prepare_meta_assets`.

**Set `special_ad_categories`** when the vertical requires it — housing,
credit, employment, social issues. Getting this wrong is a policy violation,
not a performance problem.

Extend with `add_meta_ad_set` and `add_meta_ad`. `duplicate_meta_campaign`
clones a winner rather than rebuilding it.

## Audiences and targeting

`browse_meta_targeting` and `search_meta_targeting` to explore;
`analyze_meta_audiences` and `get_meta_audience_insights` to judge. Overlapping
audiences bid against each other — check before adding another.

## Creative fatigue is the Meta-specific failure

`detect_meta_creative_fatigue` finds ads whose performance is decaying from
repetition rather than from targeting. On Meta the fix is usually new creative,
not a new audience or a higher bid. Check fatigue before recommending a budget
change.

## Leads

`list_meta_lead_forms`, `get_meta_lead_form_submissions`. Lead volume without
lead quality is a vanity metric — say so when the data allows.

## Optimising

`analyze_meta_wasted_spend`, `optimize_meta_budget`, `optimize_meta_placements`,
`explain_meta_anomaly`. All produce proposals.

## Writes

**Meta campaigns are created ENABLED and start spending.** Call
`pause_meta_campaign` immediately after creating, in the same turn, unless the
user asked for it to go live — then read the status back before saying it is
paused. Otherwise follow `adagnt-agent`.

View saved version →

---
name: adagnt-performance
description: Cross-platform performance review — pull metrics from Google, Meta, LinkedIn, TikTok, Amazon, and AppLovin, compare ROAS/CPA against targets, explain anomalies, and turn findings into ranked recommendations. Use for weekly reviews, "how are my ads doing", or investigating a metric change.
---

# AdAgnt Performance Review

Answer two questions with evidence: *is spend producing what the strategy targets?* and *what single change would improve results most?* Read-only until the user approves an action.

## Step 1 — Establish the yardstick

Read `STRATEGY.md` for target CPA/ROAS, monthly budget, and prior review notes in Performance History. A number is only good or bad relative to these targets. If no targets exist, ask for them (or agree on a provisional one) before judging anything.

Pick the window with the user: default to the last 30 days with the prior 30 as comparison. Avoid windows under 7 days — daily noise masquerades as trend.

## Step 2 — Pull the data

Query every connected platform that has spend:

- Google: `get_campaign_performance` (use `lookback_days` or `start_date`/`end_date`)
- Meta: `get_meta_campaign_performance`; drill into ads with `analyze_meta_ad_performance`
- LinkedIn: `get_linkedin_campaign_performance`; engagement detail via `get_linkedin_engagement_metrics`, creative-level via `analyze_linkedin_creative_performance`
- TikTok: `get_tiktok_campaign_performance`; ad-level via `get_tiktok_ad_performance`
- Amazon: `amazon_get_sp_campaigns_report`; search terms via `amazon_get_sp_search_terms_report`, Sponsored Brands via `amazon_get_sb_campaigns_report`
- AppLovin: `applovin_get_advertiser_report`; cohort return via `applovin_get_roas_cohort_report`, creative-level via `applovin_get_creative_performance`

Add context where it helps: `get_benchmark_context` (Google vertical benchmarks), `get_campaign_targeting` and platform equivalents when targeting might explain results.

## Step 3 — Normalize and compare

Build one table across platforms: spend, impressions, clicks, CTR, CPC, conversions, CPA, revenue, ROAS — per campaign, with a platform subtotal and a grand total. Then flag:

- Campaigns above/below target CPA or ROAS (sorted by spend, so the biggest problems surface first)
- Spend concentration: does the top campaign deserve its share?
- Trend vs the prior window: what moved more than ~20%?
- Cross-platform efficiency: cost per conversion by platform — but note attribution differences (platform-reported conversions overlap; don't sum them as truth)

## Step 4 — Explain the anomalies

For any metric that moved sharply, get a causal read before recommending anything:

- Google: `explain_performance_anomaly` (pass `metric`, `period_start`, `period_end`)
- Meta: `explain_meta_anomaly` · LinkedIn: `explain_linkedin_anomaly` · TikTok: `explain_tiktok_anomaly`

Check creative fatigue when CTR decays with stable targeting: `detect_meta_creative_fatigue`, `detect_tiktok_creative_fatigue`. Verify tracking before blaming performance: a conversion cliff is often a broken tag — `audit_conversion_tracking`.

## Step 5 — Recommend, ranked by expected impact

Present at most five recommendations, each with: the evidence, the action, the tool that executes it, and the expected effect. Typical shapes:

1. **Reallocate budget** toward efficient campaigns — preview with `optimize_budget_allocation` (Google), `optimize_meta_budget`, `optimize_linkedin_budget`, `optimize_tiktok_budget`
2. **Pause** a chronic underperformer — `pause_campaign` and platform variants
3. **Refresh creative** where fatigue is detected — hand off to `adagnt-ad-copy`
4. **Fix bidding** — `update_bid_strategy` when the strategy fights the objective
5. **Cut waste** — if waste is a theme, run the full `adagnt-wasted-spend` audit instead of patching here

Every one of these except the preview calls writes to a live account: confirm explicitly, execute once, verify with a read tool, never auto-retry.

## Step 6 — Write back what you learned

Append a dated review entry to STRATEGY.md → Performance History: window, headline numbers vs target, anomalies explained, actions taken (with IDs), and the next review date. Optionally set up continuous watching: `create_monitor` / `test_monitor` for metric alerts, `schedule_brief` for recurring reports, `generate_report_now` for a one-off.

## Intelligence Layer

Platform-reported ROAS is the platform's claim, not the ledger's. If a revenue source is connected (`list_revenue_sources`), anchor Step 3 on `get_true_roas` — revenue ÷ spend with a scale/keep/fix/kill verdict per campaign — and use `get_revenue_attribution` to explain gaps between reported conversion value and actual revenue. The `adagnt-revenue` skill covers the full workflow.

View saved version →

---
name: adagnt-revenue
description: Connect real revenue sources (GA4, Shopify, Stripe, Klaviyo) and judge campaigns by true ROAS — revenue divided by spend — instead of platform-reported conversion value. Use when the user asks what their ads actually earn, wants to connect a store or analytics source, or questions the numbers their ad platforms report.
---

# AdAgnt Revenue & True ROAS

Ad platforms grade their own homework: the conversion value Google or Meta reports is their claim about what they drove. This skill wires in the ground truth — actual revenue from the user's store, payment processor, or analytics — and judges every campaign against it.

## Step 1 — Connect a revenue source

Check what's already wired up with `list_revenue_sources`. If nothing is connected (or the user mentions a new source), onboard one with `connect_revenue_source`:

- `source` — one of `ga4`, `shopify`, `stripe`, `klaviyo`. Pick whichever is closest to the money: Stripe or Shopify if they charge there, GA4 if e-commerce tracking is solid, Klaviyo for email-attributed flows.
- `property_id` — the store/property identifier. Optional in sandbox; ask for it on live accounts.
- `average_order_value` — sandbox only: calibrates the simulated revenue stream. Ask for a realistic figure rather than defaulting, so sandbox numbers look like the user's business.

Connecting is a write, but a safe one — it creates a data connection, not an ad-account change. Still confirm the source and identifier with the user before calling, and verify afterward with `list_revenue_sources` (check sync status, not just presence).

One source is enough to start. If the user connects several, be explicit that revenue is joined from all of them — don't double-count a Shopify order that also shows up in Stripe; ask which source is authoritative for order revenue.

## Step 2 — Read true ROAS

`get_true_roas` returns per-campaign revenue ÷ spend from the connected sources, ranked worst-to-best, each with a verdict. What the verdicts mean and what to do:

- **kill** — spend with no revenue to show for it over the window. Recommend pausing; the burden of proof is on the campaign now. Check one thing first: is the sales cycle longer than the date range? A 30-day window will condemn a 60-day B2B cycle unfairly.
- **fix** — real revenue, bad ratio. Something specific is broken: targeting, landing page, bid strategy, or creative. Diagnose before touching budget — `adagnt-performance` has the anomaly tools.
- **keep** — earning its budget. Leave it alone. Not every campaign needs an intervention this week.
- **scale** — high true ROAS with headroom. Propose a budget increase in steps (20–30% at a time), not a doubling — efficiency usually falls as spend rises.

Set `min_spend` so tiny campaigns don't pollute the ranking (default 10 is fine; raise it on large accounts). Use the same `date_range` the user's targets are stated in.

Present the ranking worst-first, exactly as returned — the user's biggest losses are the lede, not the wins.

## Step 3 — Explain the attribution gap

`get_revenue_attribution` returns, per campaign and platform, both the platform-reported conversion value and the actual attributed revenue — and the gap between them. When the user asks why the numbers disagree (they will), the honest explanation:

- **Platforms over-claim.** Each platform attributes any conversion it touched, so the same order is claimed by Google *and* Meta. Summing platform-reported value counts money twice; connected revenue counts it once.
- **View-through and window inflation.** A platform may claim a sale because someone saw an ad a week before buying through another door. Revenue-side attribution is stricter.
- **Under-reporting happens too.** Blocked tracking, iOS privacy limits, and offline sales make platforms miss revenue they genuinely drove. A gap in either direction is information.

The rule of thumb to give the user: **platform numbers for optimizing within a platform, true ROAS for deciding between platforms and for judging total spend.** A campaign is never "actually profitable" on platform-reported value alone.

## Step 4 — Act on it

Verdicts are recommendations, not actions. Any pause, budget change, or reallocation that follows goes through the normal write-tool discipline: exact payload shown, explicit yes, one call, verify with a read tool. For cross-platform budget moves based on true ROAS, `optimize_cross_platform_budget` files a plan to the approval queue by default — keep it that way. Record what was decided with `update_strategy` (`append_learning`) so next month's review starts from this one's conclusions.

View saved version →

---
name: adagnt-setup
description: First-run onboarding for AdAgnt. Connects the MCP server, walks the user through OAuth for each ad platform, verifies every connection, and seeds a STRATEGY.md so all later work is context-aware. Use in a fresh workspace or whenever connections need re-checking.
---

# AdAgnt Setup

Bring a new workspace from zero to fully connected. Work through the phases in order and do not skip verification — every later skill assumes the checks below have passed.

## Phase 1 — Confirm the MCP connection

1. Check whether AdAgnt tools (for example `get_connections_status`) are available in this session.
2. If they are not, the server is not registered yet. Point the user at the connector configs in `plugins/` for their client:
   - Claude Code: `plugins/claude-code/.mcp.json`
   - Cursor: `plugins/cursor/mcp.json`
   - Codex: `plugins/codex/config.toml`
   - ChatGPT: `plugins/chatgpt/README.md`
   The default local endpoint is `http://localhost:8734/mcp`.
3. Once tools appear, call `get_usage_status` to confirm the account is active and to learn the plan's tool-call quota. Tell the user what plan they are on and how much headroom they have.

## Phase 2 — Connect ad platforms

1. Call `get_connections_status` (no arguments) to see which of Google Ads, Meta Ads, LinkedIn Ads, and TikTok Ads are already linked.
2. Ask the user which platforms they actually advertise on. Do not push them to connect platforms they do not use.
3. For each missing platform, direct the user to the AdAgnt dashboard to complete OAuth in their browser. Never ask for passwords, tokens, or API keys in chat — authorization happens only through the platform's own consent screen.
4. After each authorization, re-run `get_connections_status` until the platform shows as connected.

## Phase 3 — Verify accounts

1. Call `list_connected_accounts` for each connected platform (pass the `platform` argument) and show the user the accounts found.
2. If more than one account exists per platform, ask which is primary and call `switch_primary_account` accordingly.
3. Sanity-check read access with one cheap read per platform: `list_campaigns` (Google), `list_meta_campaigns`, `list_linkedin_campaigns`, `list_tiktok_campaigns`. Empty results are fine; errors are not — surface any error verbatim and stop until resolved.

## Phase 4 — Seed the strategy document

1. Look for `STRATEGY.md` in the workspace root. If it exists, read it and confirm with the user that it is current.
2. If it does not exist, gather context before writing it:
   - Call `infer_business_profile` (Google) to have the server derive vertical, audience, and goals from account history, when a Google account is connected.
   - Call `get_business_profile` to read anything already saved server-side.
   - Ask the user for whatever is still missing: what they sell, who buys it, main competitors, target CPA or ROAS, monthly budget, brand voice.
3. Create `STRATEGY.md` with the six sections defined by the `adagnt-strategy` skill: Business Profile, Target Audience, Competitive Landscape, Campaign Strategy, Brand Voice, Performance History. Leave `Performance History` as an empty log with a dated "workspace initialized" entry.
4. Mirror the durable facts server-side with `save_business_profile` (vertical, size, audience, geography, goal, seasonality) so tools that read the profile behave consistently.

## Done criteria

- MCP tools respond and quota is known.
- Every platform the user advertises on shows connected in `get_connections_status`.
- `list_connected_accounts` returns the expected accounts and a primary is chosen.
- `STRATEGY.md` exists with all six sections filled in (Performance History may be just the init entry).

Report a short summary: platforms connected, accounts selected, plan/quota, and the path to `STRATEGY.md`.

View saved version →

---
name: adagnt-strategy
description: Create and maintain STRATEGY.md, the workspace's persistent marketing memory — six canonical sections read before every campaign action and updated with learnings after. Use when initializing strategy, updating it after results, or when any other skill finds it missing.
---

# AdAgnt Strategy Document

`STRATEGY.md` (workspace root) is the single source of truth that makes every session strategy-aware instead of starting from zero. Two rules govern it:

1. **Read before acting.** Any skill that researches, creates, edits, or reviews campaigns loads STRATEGY.md first and honors it.
2. **Write back after learning.** Campaign launches, performance reviews, audits, and concluded tests each append what was learned.

## Canonical structure — exactly these six sections

```markdown
# Marketing Strategy — {Business Name}
_Last updated: {YYYY-MM-DD}_

## 1. Business Profile
What is sold, to whom, at what price point; the core value proposition;
website; vertical; business model (e-com, SaaS, lead-gen, local…);
seasonality; regulated-vertical constraints if any.

## 2. Target Audience
Primary and secondary segments: who they are, the pain that brings them,
where they search/scroll, objections, and the language they use.
Geographic scope. Explicit exclusions (who NOT to target).

## 3. Competitive Landscape
Main competitors and how each positions; our differentiation;
whether we bid on competitor brand terms (and whether they bid on ours);
benchmark context worth remembering.

## 4. Campaign Strategy
Goals as numbers: target CPA and/or ROAS, monthly budget and its split
across platforms; which platforms and campaign types we run and why;
naming convention; standing rules (e.g. "never exceed $X/day without
asking", "always exclude existing customers").

## 5. Brand Voice
Tone in a few adjectives; words and claims to prefer; words and claims
that are banned; compliance requirements; approved proof points
(reviews, awards, stats with sources); winning copy patterns from tests.

## 6. Performance History
Append-only dated log, newest first. One entry per event:
- **{YYYY-MM-DD} — {launch|review|audit|test|change}:** what happened,
  IDs involved, the numbers, the lesson, next check-in date.
```

## Creating STRATEGY.md

1. Gather from the server first: `infer_business_profile` (derives a profile from Google account history), `get_business_profile` (anything previously saved), `get_benchmark_context` (vertical benchmarks for section 3), `list_campaigns` + platform equivalents (what already runs, for section 4).
2. Interview the user for what tools cannot know: pricing, differentiation, brand voice, budget, targets. Ask focused questions; do not fabricate placeholders that look like facts.
3. Write the file, marking anything unconfirmed as `TBD — confirm with user`.
4. Sync durable facts server-side with `save_business_profile` (`business_vertical`, `business_size`, `target_audience`, `geographic_focus`, `primary_goal`, `seasonality`) so server-side tools see the same profile.

## Maintaining it

- **After a campaign launch** (`adagnt-campaigns`): log the launch with IDs, budget, hypothesis, review date.
- **After a performance review** (`adagnt-performance`): log numbers vs targets, anomalies explained, actions taken. If a target changed, update section 4 — history logs events, but current truth lives in sections 1–5.
- **After a waste audit** (`adagnt-wasted-spend`): log waste found, cuts made, expected savings.
- **After a copy test concludes** (`adagnt-ad-copy`): move the winning pattern into section 5.
- Keep Performance History readable: one entry per event, newest first; when it grows past ~30 entries, compress the oldest into a short "lessons so far" digest at the bottom of the section.
- Update the `Last updated` date on every edit. Never silently rewrite history entries — append corrections instead.

## Conflict rule

If a user request contradicts STRATEGY.md (budget cap, banned claim, excluded audience), pause and surface the conflict: quote the strategy line, ask whether to override once or to update the document. The strategy is the user's own prior decision — protect them from accidentally violating it, but the user always wins.

View saved version →

---
name: adagnt-tiktok-ads
description: TikTok Ads through AdAgnt — video and carousel campaigns, ad groups, targeting, geo performance, creative-fatigue detection and asset upload. Use for any TikTok ads task. 29 tools.
---

# TikTok Ads

29 tools: 14 read, 15 write.

## Start here

`list_tiktok_campaigns`, `get_tiktok_campaign_details`,
`get_tiktok_campaign_performance`. Structure is campaign → ad group → ad;
`list_tiktok_ad_groups` and `list_tiktok_ads` drill down.

Everything needs an `advertiser_id`.

## Assets before campaigns

TikTok rejects work whose creative is not already uploaded and valid. Do this
first, every time:

- `validate_and_prepare_tiktok_assets`
- `upload_tiktok_images`
- `validate_video`

`discover_tiktok_assets` shows what is already available.

## Building

- `create_tiktok_video_campaign` — the default; TikTok is a video platform
- `create_tiktok_campaign` — the generic entry point for other formats

There is no carousel *campaign* tool. Carousels are built as a generic campaign
plus cards: `create_tiktok_campaign`, then `create_tiktok_carousel_card` per
card, then `add_tiktok_ad`.

Extend with `add_tiktok_ad_group` and `add_tiktok_ad`.

## Targeting

`search_tiktok_targeting`, `get_tiktok_audience_insights`. TikTok's interest
targeting is broader than Meta's; over-narrowing starves delivery.

## Creative fatigue is the TikTok-specific failure

`detect_tiktok_creative_fatigue` — TikTok creative decays faster than anywhere
else in the stack. When performance drops, check fatigue **before** touching
budget or targeting; the answer is usually a new video.

## Optimising

`analyze_tiktok_wasted_spend`, `analyze_tiktok_geo_performance`,
`optimize_tiktok_budget`, `explain_tiktok_anomaly`.

Geo performance is worth a look on TikTok specifically — delivery skews
regionally more than the other platforms, and `analyze_tiktok_geo_performance`
often finds a region carrying or dragging the whole campaign.

## Pausing

**TikTok campaigns are created ENABLED and start spending.** Call
`pause_tiktok_campaign` immediately after creating, in the same turn, unless the
user asked for it to go live — then read the status back before saying it is
paused.

When fixing a live account, pause at the level the problem lives:
`pause_tiktok_ad`, `pause_tiktok_ad_group`, `pause_tiktok_campaign`. Pausing a
whole campaign for one bad ad is a blunt instrument — say which you are
proposing and why.

View saved version →

---
name: adagnt-wasted-spend
description: Wasted-spend audit across all six platforms — find budget going to non-converting terms, audiences, and placements; mine negative keywords from search terms; propose budget reallocation. Use for "where am I wasting money", cost-cutting passes, or monthly hygiene.
---

# AdAgnt Wasted-Spend Audit

Find money leaving the account without producing conversions, prove it with data, and stop it — with the user approving every cut. Target output: a dollar figure ("$X/month is going to Y for zero conversions") plus the fixes.

## Step 1 — Scope

Read `STRATEGY.md` for target ROAS/CPA (waste is defined against these) and check Performance History for previous audits — don't re-flag things the user consciously chose to keep. Default window: last 30–60 days; too short and low-volume keywords look unfairly bad.

## Step 2 — Run the platform audits

Run every audit for platforms with spend; each returns ranked waste findings:

- Google: `analyze_wasted_spend` (pass `target_roas` when the strategy defines one)
- Meta: `analyze_meta_wasted_spend`
- LinkedIn: `analyze_linkedin_wasted_spend`
- TikTok: `analyze_tiktok_wasted_spend`
- Amazon: no single audit tool — pull `amazon_get_sp_search_terms_report` and treat search terms with spend and zero attributed sales as the waste; negate with `amazon_create_sp_negative_keywords`
- AppLovin: `applovin_get_advertiser_report` against the campaign's `applovin_set_roas_target`

## Step 3 — Mine search terms for negatives (Google)

The single richest source of waste is queries that trigger ads but never convert:

1. Call `analyze_search_terms` with a matching `lookback_days` and a `min_clicks` floor (e.g. 5) so you judge terms with real data.
2. Sort candidates into:
   - **Irrelevant intent** — job seekers, DIY, free-seekers, wrong product entirely → negative, exact or phrase as appropriate
   - **Money drains** — relevant-looking terms with meaningful spend, zero conversions over the full window → negative or bid down, case by case
   - **Wrong-bucket terms** — converting terms landing in the wrong ad group → add as exact keywords where they belong (`add_keywords`) so they stop cross-matching
3. Propose the negative list grouped by theme with the spend each theme burned. Apply only after approval with `add_negative_keywords` (mistakes are reversible via `remove_negative_keywords`, but blocking a converting term costs real revenue — double-check anything ambiguous with the user).

## Step 4 — Audience and placement waste (Meta / LinkedIn / TikTok)

- Meta: `analyze_meta_audiences` for saturated or overlapping audiences; `optimize_meta_placements` for placements that spend without converting; `detect_meta_creative_fatigue` when frequency is high and CTR is sliding.
- LinkedIn: compare across campaigns with `get_linkedin_campaign_performance`; check `get_linkedin_campaign_targeting` for audiences that are too broad for the budget.
- TikTok: `analyze_tiktok_geo_performance` for regions that drain budget; `detect_tiktok_creative_fatigue` for worn-out creative.

Also confirm the "waste" is real before cutting: `audit_conversion_tracking` — untracked conversions look identical to no conversions.

## Step 5 — Reallocate what you saved

Preview a rebalance with `optimize_budget_allocation` (Google; use `max_change_percentage` to keep moves conservative, `min_daily_budget` to protect small campaigns) and `optimize_meta_budget` / `optimize_linkedin_budget` / `optimize_tiktok_budget`. Present the before/after budget table.

## Step 6 — Present, apply, log

Deliver the audit as: total estimated monthly waste, findings ranked by dollar impact, and the proposed actions (negatives to add, placements/audiences to exclude, campaigns to pause via `pause_campaign` and platform variants, budgets to shift).

Apply only what the user approves — one call per write tool, verify with a read tool after, never auto-retry a failed write. Then append a dated entry to STRATEGY.md → Performance History: waste found, actions taken, expected monthly savings, and a note to re-check impact at the next review.