MCP tool reference

Stall finder: where HIGH-INTENT visitors (the top 25% of sessions by conversion propensity) and the largest segments stall at a step: product page → cart → checkout → purchase, form view → start → submit, and visit → each declared goal. Each step is compared with the rest of the site this week (vs_site) and with the same visitors over their trailing weeks (vs_trailing). Read-only: nothing is drafted, created or changed. `status` is stalls_found, no_stalls or insufficient_traffic; insufficient_traffic means "not enough traffic to call a stall yet", which is NOT the same as no stalls, so say so plainly. A finding must clear every gate: 100 sessions plus 20 passes and 20 drop-offs on each side, a gap that survives a 5% false-discovery-rate correction across every step and cohort tested, an interval entirely below zero, and a rate at least 10% below the comparison. Each finding gives the step, the cohort, both rates, the gap with its interval, sessions per week, stalled sessions per week and value per week (when conversions carry revenue), ONE `proposed_action` (text only; `tool` names what would create it as a draft, and only after a human approves) and a `read_plan` (holdout, days needed to read a fix that closes half the gap, smallest effect readable in 28 days). A finding is a lead to test, not proof: never call a fix effective until its holdout test reads. `degraded` set means the requested window timed out and this is a this-week-only read with no vs_trailing comparison: say so. `commerce_pages: false` means the site had no product, cart or checkout pages in the last 7 days, so the shop funnel was skipped. A timeout error means no result at all, never "no stalls". `source` says where the counts came from: "rollup" is the per-step daily rollup (complete UTC days through yesterday; the high-intent cut is taken PER DAY there, so a session is high intent relative to its own day's traffic, and the threshold reported is the scored-weighted mean of the daily cuts), "raw" is the on-demand scan including today so far, used whenever the rollup does not cover the whole window. A weekly pass reads the rollup only and, for each finding, posts one notification (kind stall_finding, one per step, cohort and ISO week; read them with list_notifications), files the proposed action as a stall_step experiment proposal that a human accepts to get an unpublished draft (nothing goes live without approval), and emits a stall.found agent event.

Daily ad spend + performance per campaign, pulled from the connected ad platforms (Google Ads via GAQL, Meta via Insights) by the ad-platform sync cron, joined to the site's observed UTM traffic. Per row: platform, campaign_ref (the provider's campaign id — the value pause_ad_campaign / set_ad_campaign_budget take), campaign name + status from the metadata pull, windowed totals (spend_micros — micros, 1 USD = 1,000,000 — impressions, clicks, conversions, currency), and `traffic` (sessions / converting_sessions / conversion_count AXO observed for the matching utm_campaign). BE HONEST ABOUT ATTRIBUTION when reporting this: the traffic join is normalized-name equality between utm_campaign and the platform campaign name — a convention join, NOT click-id attribution and NOT causal — and the platform's `conversions` column uses the platform's own attribution model, so it will not agree with AXO's observed conversion_count; they measure different things. `traffic: null` means no utm_campaign matched the campaign name, not that the campaign drove no visits. Keyset-paginated: pass back next_cursor until it is null.

AI assistant usage: conversations, messages, tokens, estimated cost.

Read the AI generation history for a content variant — the prompt + guardrails snapshot + provider + model + DAM provenance that produced each piece of AI-generated content on this variant. Use to audit off-brand creative ("why does this image feel wrong?") or to trace why a specific variant looks the way it does. Returns { generations, count } with newest first. Each row carries prompt, response, model, tokens, inferred_cost, guardrails (brand_voice + active_briefs + segment), and dam_provider when the asset was push-through'd to a customer DAM.

Get dashboard analytics overview: total sessions, conversions, revenue, segment breakdown, and trend data for the current site. hour_distribution is session COUNTS only — for conversion rate by time of day / day of week, use get_daypart_performance.

Get backtest results showing segment performance, variant impact, conversion rates, and revenue attribution. All figures are windowed (default 90 days) and the window is echoed back in the response. Retired segments are included when they still took sessions in the window, because retiring a segment does not stop traffic scoring into it. This is not the verdict on whether personalization is working — use get_scorecard for that.

Read real exposures and subsequent conversions for every arm of a component test: `arms` lists the unchanged-page control (A) and each treatment (B, C, ...) with sessions, conversions, cvr, requested vs observed share, relative lift vs the control and a per-arm peek-safe verdict adjusted for the number of treatments; `winner`, `collecting`, sample floors, uncertainty and a sample-ratio check against the configured equal split sit at the top level. Mixed-arm, preview and simulator sessions are excluded. A failed render is not a treatment exposure. Two-arm tests keep their familiar A/B readout. Cross-site super-admin callers must pass site_id from get_account_status; site-scoped callers stay on their own site.

Read component delivery and click events by placement and revision. Counts represent observed events, not causal conversion lift; preview traffic is excluded. Cross-site super-admin callers must pass site_id from get_account_status; site-scoped callers stay on their own site.

Per-arm exposures (distinct sessions actually shown the arm, Original included), conversions after first exposure, conversion rate with uncertainty, requested vs observed traffic share and a sample-ratio-mismatch check, plus evidence_qualification. Repeated-look certification is withheld until the cumulative finalized outcome/analysis policy is verified; descriptive rates are not automatically causal lift. Site-holdout visitors are never in a content test; the Original arm is the test's own control.

Read a bounded GA4 report for this site’s selected property. Use list_customer_analytics_connections to find its connection ID. A signed-in operator must connect Google in Integrations first. The tool cannot choose a different property or use staff Workspace credentials. Dates are YYYY-MM-DD; inspect returned limitations and provider metadata before comparing with AXO. Paginate with offset; Search Console does not guarantee all rows.

Read a bounded Search Console report for this site’s selected property. Use list_customer_analytics_connections to find its connection ID. A signed-in operator must connect Google in Integrations first. The tool cannot choose a different property or use staff Workspace credentials. Dates are YYYY-MM-DD; inspect returned limitations and provider metadata before comparing with AXO. Paginate with offset; Search Console does not guarantee all rows.

Conversion performance by day-of-week × hour-of-day, in the visitor's LOCAL time (first-touch stamps: the hour the visit STARTED; dow 0=Sunday..6=Saturday). THE source for "when do visitors convert / when should campaigns run?" — never infer timing from a time-based segment's lift, which usually comes from the segment's other clauses. Returns: `grid` (dow×hour cells, up to 168 — only combinations with at least one session appear, so never index it positionally; raw sessions and converting_sessions per cell, no per-cell rate on purpose: cells are small, judge significance from the counts before ranking them), `weekday_weekend` and `hour_blocks` rollups (with rates — prefer these for headlines; blocks are a fixed vocabulary, so check the grid for a peak straddling a block boundary), `window` (rates are floored at first conversion, like the dashboard CVR — days/floored say what span the rates actually cover), and `coverage` (measured_sessions the grid describes, vs rate_window_sessions — every session in that same floored window). Numerators are primary-goal converting sessions (the conversions ledger, as in get_analytics conversion_stats), but computed over the measured subset only: sessions without first-touch stamps and simulator sessions are EXCLUDED, never guessed, so rates here legitimately differ from conversion_stats wherever coverage is below 100% or simulator traffic exists — that gap is deliberate exclusion, not a data problem.

The decision→outcome ledger: every recorded measurable decision (variant created/updated, offer created, trigger created, proposal accepted) with whether it MEASURABLY worked. Each row carries outcome_status: "pending" = recorded but the evidence lane has not yet cleared its own sample gate (NOT a failure, NOT a zero — the sweep re-checks ~daily); "measured" = outcome carries the verdict (higher/lower/inconclusive) WITH its confidence interval, p-value, both arms' sample sizes, and peek_safe where available — "inconclusive" is a real measurement of "we can't tell"; "not_measurable" = structural (never exposed inside the maximum window, empty control arm that cannot fill, or the accepted proposal minted nothing with a lift lane) with the reason named in the outcome. Never present a pending or not_measurable decision as evidence for or against the change. Filter by since_days / decision_kind / entity_type; page with the cursor from next_cursor.

Get recent site events: pageviews, clicks, conversions, custom events. Paginated: the response carries `next_cursor` — pass it back as `cursor` to continue, until it is null.

Form conversion funnel analytics: views → starts → submits → abandons, per form and per page, with field-level drop-off. Counts and rates exclude sessions classified as automation at ingest (crawlers such as Meta's ad landing-page checker, which focuses an email field and leaves); each form reports that excluded volume under `automation`. OptinMonster popups (no <form> element) are tracked with form_id om-<campaignId>.

Read prelaunch 50/50 copy-test traffic advice for one zone and audience. Uses observed personalized zone exposures over 28 days, not all eligible visits. Fixed-horizon estimates may be unknown and do not qualify repeated-look decisions or automatic launch. Does not create, publish or launch anything.

Per-arm delivered-session descriptive results for a layout experiment: counts, conversions, rates, fixed-time p-values, sample-ratio checks and vitals guardrails. Read evidence_qualification first. peek_safe_significant is withheld until a finalized cumulative cohort and frozen analysis policy are verified; the legacy z heuristic cannot certify repeated-look decisions. Delivered-session rates are not automatically intent-to-treat causal lift. Read-only.

CONVERSION-RATE lift vs the always-on holdout control group (not revenue — revenue lift lives on get_scorecard). Default: the per-variant table; each row carries `zone_label` and `variant_label`, the friendly names to use instead of `zone_key` or ids. Pass `offer_id` for the per-OFFER roll-up (#1476): treated-vs-holdout CVR pooled across the offer's placements, delivery volume, and — once discount capture is live — an observed `redemption` block (redemptions, order-level discount spend, holdout-redemption leakage signal) that is explicitly NON-CAUSAL: redemption says people accepted free money, and the holdout comparison is the causal number. The response's `not_measured` array names what the report deliberately does not claim (incremental margin needs observed exposure). Pass offer_id="" (empty string) to get every offer on the site. The response carries `holdout_epoch` — arms are measured per VISITOR only since `epoch_started_at` (#1380 cutover); pre-cutover per-visit sessions are excluded, so a window that spans the cutover covers fewer sessions than its day-count implies.

The default report for "what did each placement, version and segment do for goal X" (email sign-ups, affiliate clicks, any site goal or raw event). Use it before get_zone_exposure_report, which stays available for the zone-level saw / did not render diagnostics. Three levels. (1) Placements: ONE row per thing placed, on however many pages. Every page that places the same component outside a test is one row; a component test is one row with the same test on other pages (the same arm letters, each arm rendering the same component, pinned revision and design settings, never matched on names or product lists; one test can use several components), a test that renders differently is its own row saying how, and the same component live outside a test on other pages joins it; version labels drop page tokens, item counts and status words; content zones on different pages are one row only when their names match once the page is taken out, and never when two of them are on the same page; a content or layout test is its own row. `pages`, `page_count` and `members` list its pages, each with its own `state` and test; `state.label` reads "In a test on 5 pages", "Live on 5 pages", or both. `goal_mixed` is set when its pages disagree on the goal: say "mixed" and list each goal with its pages. `aimed` lists placements built for the goal (its goal set on the placement, `goal_source` "set", or else a current campaign holding its content names it, "campaign"); `other` lists the remaining placements on pages where the goal happened; `not_shown` counts the rest. `pooling_note` says how the pages were added up, or why some were kept apart. Optional `qualified_views` contains separate geometry-qualified canary counts per source. Coverage is partial or unknown: empty cells stay null, source counts are non-additive, and none can be divided by legacy renders or used as a causal estimate. Use returned visibility rules and source windows; old caches may lack these measurements. Optional `attribution` carries separate same-session associations under `placement-attribution/1`: `after_click`, `after_qualified_view` and `associated` contain outcome-event and visit counts per source. Missing channels remain null and coverage is partial or unknown; check source status and reason. `direct` is null because accepted origins are not instrumented. Read `outcome_source`: primary conversion records, goal-hit observations or selected events have different meanings; a goal event does not prove accepted form completion. Categories are exclusive per outcome/source, while each visit belongs to its strongest category. Distinct legitimate outcomes remain distinct. Rows across sources are non-additive and do not establish causal lift. This section supports only its declared source types and windows; never infer a portfolio union or a historical accepted origin. (2) `variants`: who each version is for (`audience_label`), visitors shown (for a component test, visitors the test put in the version, rendered or not), conversions and rate; a test's versions, the original included, count from the test's start (`test.started_at`, each page's own when added up), so exposures from before the test never enter the comparison, added up across the placement's pages, with `by_page` giving each page's own counts. The versions of a component test are added up across the per-page tests by recorded arm/render identity; each page's test splits visitors the same way, and tests with different versions or splits stay separate rows. A visitor who reached two of the pages counts once on each. `comparison.kind` is "vs_original" (a test version against its original; separate page-test totals are descriptive with no pooled significance claim, while an individual source comparison uses the existing 0.05 / new versions method), "original_arm" (the original itself) or "not_in_test" (rates only: its effect can't be separated from other placements on the same pages; describe its segment and page performance; a test is optional). (3) `segments` under each version, added up the same way: the segment on the visitor's first pageview of the page, for both groups. For an individual source test, `control` is the original in the same segment, with the existing peek-safe test and then Benjamini–Hochberg correction (`p_adjusted`). Cells added across separate page tests are descriptive, with no combined decision or adjusted p-value. Source-specific `by_page.comparison` is available on newly computed reports; never reconstruct missing cached decisions from totals; for a version outside a test it is held-out visitors in the same segment and pages, rates only. A version for a custom audience or a targeting rule is not split by segment (`segments_note`). Personalized vs control group is in `pages`, the By page table, ONCE per page: everyone on the page who was not held out vs held-out visitors on the same page, counted from each visitor's first view of the page (from the visit's first event for every page), with the placements on it. The control group is held out site-wide, so that number covers every placement on the page: never present it as one placement's effect. Placement rows point to their pages with `page_ids`. The Scorecard headline's 30-day rates for visits before 2026-10-05 count from the visit's first score call instead, so they can read lower until those days leave the window. Every comparison carries `verdict` (too_early below the gate of enough visitors and 20 conversions per group, which is not a flat result and carries no p; higher, lower or no_clear_difference once the peek-safe test decides; descriptive for rates only), `counts_line` ("1 of 6 vs 0 of 4") and a plain `summary`; quote the counts with every rate. For a click or form goal (affiliate click, an outbound click-out goal, form submit), each placement and version also carries `inside_clicks`: clicks or submits that happened on an element inside it, added up across its pages with each visit counted once. `source` "component_click" means a component placement counted from its own click events over the whole window (`window_days`, the days it covers; `window_since` is set when the window was cut at a holdout-rate change, or for a test version when its test started inside the window: say "since" that day; for an affiliate goal only links the tag counts as affiliate, for an outbound goal links to other sites), merged with stamped clicks so a click counts once; "tagged_click" means a placement that is not a component, counted only from stamped clicks the tag sends since 2026-10-19 (`since`). Say which: never present a tagged_click count as the placement's whole history. A tagged_click zero is left out (null). It is a count with no control group: give it no verdict and never mix it into a comparison. The report's `inside_clicks.tagged_note` is true when a listed row counts from that day. Every id comes with a friendly `label`: use it, never the raw id (`label_is_id` true means no name exists). Each version (and each of its `segments` and `by_page` entries) also carries `engagement`, counted among personalized sessions with a render record (component_rendered for a component, personalization_applied otherwise): `saw`, `converted`, `direct` (reached the goal through the placement: the goal event fired inside it, or a click inside a component of the goal's link class), `influenced` (saw it, no Direct conversion, reached the goal at or after first seeing it in the same visit), `clickers` and `clicks` (any click on it), for the `full` window and `since_tracking` (visitors who saw it since 2026-10-19). A test version counts from its test's start, and only visitors the test put in it, so `saw` is never more than assigned. Read clicks from `clicks_window` and Direct / Influenced from `breakdown_window`, never mixing the two windows in one figure; `breakdown_window` null means the goal fires no event inside a placement. Display legacy saw as Rendered, not viewed or seen; rendering does not verify visibility. Display legacy influenced as Converted later: it is an observed same-session association after rendering. Do not infer an after-click/after-view split from legacy engagement; use only the separate versioned attribution section when available. Read reporting and definitions in the response, including old cached results. Ordinary placements show observed performance without a vs Original column or a winner. Placement-associated outcomes and per-page sessions are non-additive; never sum them into unique site totals. A configured test comparison requires valid assignment and analysis before claiming causality. Only a test version's vs_original comparison can support a causal conclusion when its design and analysis are valid. `summary` holds the section's tiles (placements built for the goal, how many are in a test, and their pages as one union vs the control group); `engagement` at the top says how Direct is known for the goal. The first run for a goal can take minutes, so it runs in the background: an answer with status "computing" means it is still working (ask again in a minute), and status "failed" means it did not finish (ask again with retry: true to start a new run). Answers come from a 5-minute cache: state `computed_at`, and the age when `cache.stale` is true. `state` (live, in_test, paused, draft, or mixed across pages) is read fresh: it says what the placement does now, while the counts cover the window.

Whole-site primary-conversion comparison against the currently configured holdout, including eligible content, layout and component personalization. Returns arm counts, rates, goal, control_group, holdout_epoch, simulated and a gated status. Compare only the returned allocation period; older or unknown allocation stamps are excluded. Flat/learning means no clear difference yet, not equal performance. Relative lift is null when control has zero conversions. `lift.relative_ci` is the 95% interval on that relative lift (ratio scale, asymmetric; null when either arm has zero conversions) and `lift.absolute_ci` the interval on the rate difference; state the interval alongside the lift, not the point estimate alone. Use the status and peek_safe_significant gate, not the sign of lift or p-value alone, for a conclusion. Individual content/layout/component tests and trigger holdouts have separate result tools; this is not an average of their arm results. A labeled backtest projection may accompany insufficient live data. `simulated` reports whether simulator sessions were admitted into the verdict (demo sites only, behind a super-admin override) and how many were in the window; when `simulated.included` is true and `simulated.sessions` > 0 the result is demo evidence, not customer proof, and the text summary says so first. With include_goals (default true) the response also carries `results_by_goal`: every active site goal measured on the SAME treated and held-out sessions as this verdict (up to 90 days when the daily rollup covers the window; otherwise shortened to 30 and flagged window_capped). The primary goal's verdict is THIS response's status; never present a supporting goal as the headline. Supporting (equal-priority) goals are a corrected family: `higher`/`lower` only past a stricter check-any-time bar (alpha/m, stated in `family`), `too_early` means the sample gate is not met (not a flat result), and `descriptive` (lower-priority) rows carry rates only, no verdict. A goal row `ci` and `p_value` come from that same check-any-time test, so they always agree with its status (once the sample gate is met, p_value is at or below ci.alpha exactly when it is higher or lower; below it the status is too_early whatever p says); `p_value_single_look` is a one-look figure for reference only. `results_by_goal` is null when that read failed; the primary verdict is unaffected. `allocation_check` (on the verdict and on results_by_goal) tests whether visitors split into treated and control in the configured proportions; on a mismatch the verdict is withheld (status learning, goal rows `withheld`) because the split itself is broken – report that, never a lift.

Performance metrics for a segment: sessions, conversions, rate, revenue, AOV — all of them over the sessions AXO actually classified into the segment. `unclassified_sessions` counts the sessions carrying this segment's id at confidence 0, the tag's default slot when nothing matched; they are "Default (unclassified)", none of the figures above include them, and quoting them as this segment's audience is wrong even though the tag does serve them its variants. Also returns `attribution` (30-day window): `label_timing` says how many of the converting sessions ending in this segment already carried the label BEFORE they converted - `post_conversion_label_share` near 0 means the blended conversion_rate is real, while a high share means the segment absorbs converters after the fact (their conversion behavior produced the classifying signals) and the blended rate must never be quoted as intent or opportunity. `entry_label` is the strictest cohort - sessions already in this segment at their first event - and its conversion_rate is the honest predictive number to quote when the share is high. `attribution` is null when the segment has no conversions to attribute or the measurement failed.

Sitemap crawl status, page counts, health metrics.

Tag health: 24h beacon/pageview/personalization counts, render errors, first and last event time (lifetime, not windowed), and status — healthy (beacons in 24h) | no_data (none in 24h but this site HAS reported before, so something stopped) | no_signal (never reported at all; a fresh or unvisited install, not evidence of breakage). Also per-goal liveness (goal_liveness / goals_never_fired_90d): a goal with last_fired_at null has fired ZERO times in 90 days — usually a misconfigured detection rule (wrong URL pattern, tag not on the conversion page), not an absence of conversions.

Per-trigger holdout-attributed lift: for every trigger with counted candidates in the window, the treated vs held-out conversion comparison (two-proportion z-test) plus link-token click-through. HONEST-NULL SEMANTICS, never round them to zero: `sufficient_data: false` means the sample gate (20 treated / 3 held-out candidates) has not been met and the lift/p-value fields are placeholders, not a flat result; `relative_lift` is null when the holdout arm converted zero times (no denominator — the absolute difference is still real); `links.ctr` is null when no link token was ever minted (nothing was attempted, not a 0% click rate). A trigger whose holdout arm is EMPTY may have a 0% holdout configured (safety triggers) — waiting will not fill it. An empty triggers array means no trigger had a counted candidate in the window, which is different from having no triggers (check list_triggers).

RAW performance counts for one content variant over the bandit window: impressions, conversions, conversion_rate, render errors — observational, NOT causal (conversions are counted at segment level, so the rate is a rough engagement signal, and the causal number lives on get_lift_report / get_scorecard). The response carries conversion_rate_ci95 (95% Wilson interval), `sufficient` (impressions at/above the shared per-variant floor) and a top-level `warning` when the sample is below it: at small samples the rate is noise, so do not compare two variants' raw rates — especially at very different impression counts — and re-checking until a difference appears is peeking.

Zone-level diagnostics; for placements, their versions and segments on a goal use get_placement_report, the default. Per ZONE: how many sessions SAW it (the tag recorded the render), how many should have but it never rendered, and how many were HELD OUT on the same pages, each with its rate on a chosen outcome. The outcome can be the primary goal, ANY site goal (metric "goal:<id>", including supporting goals the scorecard ignores), or a raw tag event (metric "event:affiliate_click"). Use this for "did the zone move metric X", e.g. affiliate clicks when they are not the primary goal. Three readings, kept apart. (1) `pages`: everyone who reached a page vs held out, ONCE per page pattern. The control group is held out site-wide, so every zone on the same page shares this comparison (each zone row repeats it as `causal`, scope "page"); never present it as one zone effect, because it cannot separate zones on the same page. (2) `test_comparisons` on a zone in a running test: visitors the test put in this arm vs visitors it put in the ORIGINAL arm of the same test, same measure and window (basis "assignment" for component tests, counted whether or not the component rendered; "exposure" for content and layout tests). This is the per-zone comparison; each treatment is held to 0.05 / `comparisons`. Known test comparisons begin at the later of the report start and `experiment.started_at`, including the latest content split change. Outcomes begin at the first eligible arm record. `measurement_window` equal to "unknown_test_start" preserves descriptive history but withholds statistical decisions. `counting_status` equal to "unavailable" means the count read failed: numeric compatibility fields are placeholders, never measured zeros. Page-wide holdout totals retain their separate report-window population; matching time bounds does not establish identical denominators. Display legacy SAW counts as Rendered; a render does not verify visibility. (3) saw / not rendered / held out are descriptive: saw vs not rendered is selection (visitors who stay long enough for a render differ from those who leave first), and `engagement` (saw vs held out) flatters the zone. Every verdict carries `decided_by` ("sample_gate" = too early: under the minimum sessions or 20 outcomes per group, which is not a flat result; "peek_safe_test") and `decision` (rule, alpha, z, threshold_z, p_value, interval). `p_value` is the peek-safe p of the test that sets the verdict: once the sample gate is met, higher or lower exactly when p_value <= decision.alpha (below the gate the verdict is insufficient_data whatever p says). `p_value_single_look` and `ci95` are one-look figures for reference only; never quote them beside a verdict. Grouping by goal: `goal_group` is "aimed" when one of the zone `intended_goals` is the measure, else "other" (built for another goal, or `goal_note` "no_goal_set"); `goal_grouping` counts them and is null when the links could not be read. Intended goals: the goal set on the zone or component placement ("Built for goal", `goal_source` "set", written with update_zone or update_component_placement goal_id) wins; a zone with none set takes the goal of each current (not ended or closed) campaign holding its content (`goal_source` "campaign"). For a raw event measure no zone is aimed. suggest_placement_goals proposes goals for zones with none set. Honest nulls: `relative_lift` is null when the comparison group converted zero times. `allocation_check.mismatch` true means the split did not land as configured: explain that before trusting any rate. `holdout_leaks` > 0 means held-out sessions have render records. "Converted" = the outcome happened in the session at or after the first view of a page the zone targets (for a test arm, at or after its first record in the test). The `all_zones` row counts each session once. Answers come from a 5-minute cache: `computed_at` says when the numbers were computed, and when `cache.stale` is true they are `cache.age_seconds` old (up to six hours) while a refresh runs, so state their age. Each zone row carries `lifecycle` (live, test_arm, paused or draft, with the running experiment for a test arm), read fresh on every call: it says what the zone does NOW, while the counts cover the window. Read the zone state from `lifecycle`, never from its name.

READ-ONLY: this site's own change ledger — the tenant-facing audit feed of every recorded mutation on the site: MCP tool calls by connected agents (yours and any other token's, so you can review your own past actions), dashboard edits by humans, and system/background writes. Each event carries time, actor (agent = MCP token name, human = user email, or system), action (e.g. "mcp.create_segment", "profile.delete"), tool, the recorded argument KEYS only (values are never stored — the trail is not a PII sink), entity hints, and status. Use it to answer "what changed on this site, when, and by whom / by which agent". Newest first; page with limit + cursor (pass next_cursor from the previous page — keyset, stable under new writes). Honest limits: events are recorded at the call boundary, so a row proves the call was MADE, not that it succeeded; PII-bearing READ tools appear only as a small sample (sampled_read: true) and most reads never appear at all. Changes nothing.

Read the durable, partial AI change ledger. Currently covers active AI-derived content published through manual revisions; auto-mode edits, experiment activation, pages and overrides are not yet covered. Stored application actor attribution does not prove human approval. Includes before/after snapshots, model when recorded, reversal links and keyset pagination. No mutation or rollback is performed.

List this site’s GA4 and Search Console bindings without credentials. authorization_saved means a grant is stored, not that Google currently accepts it. Use the returned id with get_customer_ga4_report or get_customer_gsc_report.

Create a custom audience from the same definition used by preview_custom_segment. Preview first, then recompute_custom_segment to materialize membership.

Create a new custom behavioral segment with a name, description, and signal rules.

Permanently delete a profile and all associated data (GDPR erasure). Removes identifiers, unlinks sessions, deletes the profile.

Designate a SITE-NATIVE form (one the customer already has — newsletter, contact, signup) for opt-in lead capture, or update its field selectors. On submit of a matching form the tag captures the email (plus name/phone ONLY when their field selectors are set here or via data-axo-*-field attributes) into Leads/profiles/CRM. Works on native Episerver/Optimizely Forms too — their AJAX submit is captured via the same vendor hook that fires form_submit. For split-name forms (First + Last as separate inputs, e.g. Episerver) set first_name_field + last_name_field and the tag joins them into the one stored name; use name_field for a single combined input. Upserts by form_selector (max 20 designated forms). This reads visitor-entered PII from the customer's own form — only designate forms the customer owns and has asked to capture; it is inert in passive mode. Verify the selector matches exactly one <form> on the live page first (e.g. via get_form_funnel form ids or probe_zone_binding).

Answer "why did this visitor see this variant?" - or why they saw nothing - with a trace assembled from records. Returns `trace`, an ordered list of claims each carrying the exact rows it rests on: the cohort the scorer assigned and the signals behind it, the holdout arm and which bucketing epoch it was made under, the zone, every live variant's targeting predicate evaluated through the same evaluator the tag itself uses, allocation, and the personalization_applied event that names what actually rendered. Also returns `answer`, the same trace rendered to text by a pure function - no model writes any part of this response. TRACED, NOT INFERRED: report the verdict and the claims AS WRITTEN, offer the cited records when asked how you know, and never supply a reason the trace does not contain. Claims marked "unknown" are first-class answers with a stated reason, not gaps to fill. The most important one: display-rule outcomes (country and schedule gates) are evaluated in the visitor's browser and deliberately never beaconed or persisted, so nothing server-side can say whether one refused this visitor - say exactly that rather than guessing. A visitor in the holdout saw nothing BY DESIGN, and that is a complete and correct answer, not a fault. Identify the visitor by their durable vt_sid visitor id (sessions.cookie_session_id, returned by get_sessions and get_profile) or by a single session id. Name a zone to ask why nothing served there; omit it to explain the most recent recorded exposure. Read-only: reading a trace never changes what AXO serves.

Export a segment's audience for a batch email campaign. Returns JSON rows by default; set format:"webhook" to POST them to a URL. For an email blast list set email_only:true — only profiles with a captured email are included (anonymous visitors excluded). Works for behavioral AND custom/affinity segments (auto-detected). include_pii is required to emit emails and is recorded for compliance.

Manually run K-Means machine-learning clustering against recent behavioral profile activity.

Get detailed profile information including timeline, identifiers, CRM attributes, lifetime signals, session history, lead status (lead_captured history), and the opportunities this profile is a contact/lead on. Also returns `propensity_model`: the measured accuracy of this site’s conversion-propensity model that feeds `scores.intent` – status graded (held-out AUC with its method, holdout counts and a predicted-vs-observed calibration table), ungraded ("Not enough conversions to grade this model yet (n/50)") or no_model, each with a plain-words headline. Quote the headline with its method, never the AUC as a bare accuracy percentage. Also returns `value_tier` (low | mid | high: the predicted order-value tier on the visitor’s latest scored session if they convert, thirds of this site’s own order values; null when the site has no order-value model) with `value_tier_model`: that model’s measured accuracy – graded (held-out pairwise concordance with its method, tier agreement and the tier cuts) or no_model with the reason ("not enough valued conversions (n/100)"). Never quote a tier without its model’s headline.

Paginated list of profiles in a segment with their identifiers. Prefer the cursor: the response carries `next_cursor` — pass it back as `cursor` to continue, until it is null. `offset` is legacy and skips/repeats rows when membership changes mid-walk. `total_members` counts the profiles AXO actually classified into the segment; `unclassified_members` counts those assigned at confidence 0 — the tag's default slot when nothing matched — and they belong to "Default (unclassified)", not to this segment. The listed rows are NOT filtered (filtering a cursor walk skips people): read each row's `segment_confidence` and treat 0 as unclassified.

List everything currently acting on one segment - zone variants, triggers, recurring audience syncs and recent exports - each annotated with whether the goals measured downstream of it are the goal the segment's conversion thesis names. Serving is zone-local, so five touchpoints can pull one segment in five directions with nothing above them noticing; this is the view where that disagreement becomes visible. Alignment is MEASURED, never inferred from copy: a variant is credited with the goals hit in sessions that saw it, a trigger with the goals hit by profiles after it fired. Below the observation floors the verdict is "undetermined" with a reason - report those as written rather than treating them as alignment. A segment whose thesis says "insufficient evidence" has no primary goal to align against, and alignment_blocked_by says so instead of every touchpoint being guessed at. Exports are annotated with whether the THESIS travelled with the membership list, not with a goal: AXO does not observe what an audience converts to off-platform. Descriptive only - this view reports what it finds and never re-targets anything. Use it when asked why a segment is underperforming, or before adding another touchpoint to a segment that already has several.

Get one segment's conversion thesis in full: which site goals it most over- or under-reaches versus the site baseline, an operator-readable reading, the evidence behind that reading (member vs site-wide sessions, conversion rates, and per-goal reach measured in the window), the confidence, and whether the thesis is stale. Works for pack, custom, ad-source, and ML-discovered segments. Every figure traces to a measurement in the window; a segment with too little traffic returns an explicit insufficient-evidence reading rather than a guess. Descriptive only - reading a thesis never changes what AXO serves.

List all behavioral segments (plus operator-built custom segments) with session counts, conversion rates, descriptions, and each segment's conversion thesis. Counts are live over the last 30 days, consistent with get_analytics segment_distribution. `session_count` is CLASSIFIED membership: the sessions AXO actually scored into the segment. Sessions the tag's fallback parked on a segment's slug because nothing matched (confidence 0) are reported separately as `unclassified_session_count` and belong to "Default (unclassified)" — never describe those as members of the named segment or fold them into its size, and when a segment shows session_count 0 beside a large unclassified_session_count, say plainly that it is the default bucket rather than an audience. The two sum to the raw stamped membership. Use this to understand how visitors are being classified. Segments AXO discovered from behavior also carry `discovery`: what the group keyed on, as plain comparisons against the site average ("about 3x the site average"), plus its size, share of traffic, how many recent refreshes it has appeared in, and a coarse quality grade. Use it to explain why a discovered segment exists. `discovery` is null for rule-based segments (read their signal_rules instead) and for discovered ones the latest run did not produce. Its comparisons are deliberately coarse and its states ("too small to characterize", "no distinguishing signals") are honest — report them as written and do not extrapolate exact figures from them. Where `discovery` says what a group keyed on and the description says WHO is in it, `thesis` says why it matters to conversion: which site goals it over- or under-reaches, a short reading, and how much evidence is behind it. `thesis` is null when none has been built yet, and carries stale:true when the goals or the segment membership changed after it was written. Use get_segment_thesis for the full evidence behind one segment. The thesis is descriptive: it does not change what AXO serves. Every row also carries `expected_alignment`: non-null when the segment's own DEFINITION is upstream of, or overlapping with, a site goal, so its lift on that goal is fixed by construction rather than discovered - a form-starter segment against a form-submit goal, or a cart-adder against a purchase goal - or MEASURED from label-vs-conversion ordering (reason `post_goal_labeling`): a large share of the segment's conversions only received the segment label at or after the conversion itself, meaning visitors are classified by behavior the conversion produces, not behavior that predicts it. Scorer rows also carry `label_timing` (30-day window): of the converting sessions ending in this segment, how many carried the label before converting - `post_conversion_label_share` near 0 means the blended conversion_rate is trustworthy, and null label_timing means the measurement did not run (not that the segment is clean). When `expected_alignment` is set, report the number if asked but never present it as a finding, an opportunity, or evidence that the segment is high-intent, and never lead an audience report with it; its `label` says why in one sentence. null means the ordinary case, where the lift IS a finding.

Get recent visitor sessions with behavioral signals, segment assignment, and page URLs. Useful for understanding real-time visitor behavior. Paginated: the response carries `next_cursor` — pass it back as `cursor` to continue, until it is null.

Link a new identifier (email, phone, external_id) to a profile.

List saved custom audience definitions and their latest computation state.

Find profiles sharing identifiers (merge candidates for deduplication).

List captured leads (lead_captured events) for this site: contact info, scheduled appointment slot, behavioral segment, and source page. Paginated: the response carries `next_cursor` — pass it back as `cursor` to continue, until it is null.

List the SITE-NATIVE forms designated for opt-in lead capture. Designated forms are the only native forms the tag ever reads values from — on submit, the email (and name/phone when field selectors are designated) lands in Leads, profiles, and CRM auto-intake. Forms can also be designated config-free by adding the data-axo-optin attribute in the site's own HTML; those do NOT appear here. Use get_form_funnel to discover which native forms exist and how they perform before designating one.

Merge two profiles. Moves identifiers, sessions, conversions from source to target, deletes source.

Mint single-use link tokens so an email sent from a third-party ESP (Klaviyo, HubSpot, Mailchimp, Braze, Salesforce Marketing Cloud) can identify the recipient on click. Give it the column the ESP list is keyed on — usually email — and it returns a merge-field column: paste axo_token (or axo_link, if you pass landing_url) into the send, and when a recipient clicks, the AXO tag on the landing page redeems it and the anonymous session merges with their known profile. Recipients with no matching profile come back under unresolved_recipients and simply get no token; their send still works, the visitor just stays anonymous. IMPORTANT: this is deterministic identity, not authentication — a forwarded email hands it to whoever opens it, so use it to personalize content, never to unlock account data, order history or PII. Tokens are single-use and expire (72h default); re-mint per send rather than reusing a column. Profiles that declined marketing consent are skipped automatically.

Preview a custom audience definition before saving. Returns counts and diagnostic hints; identifiers are never requested. No membership is changed.

Recompute a saved custom audience using its current definition and site window. Refuses externally managed audiences without a predicate.

Remove a native form's opt-in capture designation by its form_selector (see list_optin_forms). The tag stops reading that form on the next config refresh; already-captured leads are unaffected.

Search visitor profiles by email, segment, or identification status. Returns profile list with identifiers and session counts. Paginated: the response carries `next_cursor` — pass it back as `cursor` to continue, until it is null.

Remove an identifier from a profile.

Update a profile segment override or lifetime signals.

Update a segment: rename, edit description, change emoji, visibility, or signal rules.

Publish the reviewed placement version, including its binding, targeting and approved component revision. expected_version rejects intervening edits. This changes the customer site. Cross-site super-admin callers must pass site_id from get_account_status; site-scoped callers stay on their own site.

Approve a pending ad-theme suggestion into an active theme. Requires write authority and tenant approval policy permission; does not publish a content variant.

Attach a library asset to a content variant field — overwrites whatever image was on that field with the asset's blob_url. Also copies the asset's provenance (prompt, brief / reference / planner attribution, tags) into the variant's generated_metadata so the audit trail follows the image. Returns { ok, asset_id, variant_id, blob_url, field_key }. Use after search_assets surfaces an existing asset that matches what the operator wants — saves a generation call. The variant's image_url is also synced to the asset's blob_url so the runtime tag picks it up immediately.

Attach an existing resource to a campaign's manifest by REFERENCE (never a copy). Idempotent on (campaign, kind, ref_id): a repeat call updates `required`/`ref_version` and returns created:false. The ref must exist in this site or the call 404s. Attaching a variant or trigger also sets its serving-path campaign_id when unset, and is REFUSED (409) when it already serves under another campaign - detach it there first. Live content needs confirm_serving_change. `required:false` components are reported but do not gate readiness. Any change voids an approval (response `stage_reset`).

Author a "move object" placement: relocate an EXISTING element on the page to a new location, WITHOUT changing its copy or injecting new content (pure rearrangement). Creates a source zone (element_selector = the element to move) + a move_object content variant whose payload carries the destination anchor + position. Use AXO skills with browser access, or the dashboard picker, to inspect the source and destination elements and obtain source_selector + dest_selector first. Target ONE segment via segment_id, OR all_visitors:true for everyone (the default — moves are usually global). CAUTION: once published this ships to the live site within ~60s. Review both selectors and the proposed placement before publishing.

Clone a system or site template into a new site-owned template.

Close a LAUNCHED or PAUSED campaign for good, as a durable job. Stops serving (status ended), pauses its running experiments (never ends them), then snapshots the OUTCOME into the campaign (get_campaign -> campaign.outcome) with every number labeled by evidence: causal (holdout lift per variant, offer and trigger; insufficient_evidence is reported as such, never as zero), observed (the goal's converting-session rate in the live window vs the same-length window before launch - not causal), and platform_attributed (ad spend and the platform's own conversions). Writes a campaign_closed row to the decision ledger. IRREVERSIBLE: a closed campaign is read-only and cannot be relaunched; use duplicate_campaign to run it again. Requires admin scope. Does not retire pages or pause ad platform campaigns (reported as needs_operator). Pass rationale to record why. Confirm with the operator first.

Configure a product_reco variant: choose recommendation mode (auto / curated / mixed), retrieval strategy, catalog filters, catalog weights, and pinned products. A FILTER removes items ("do not recommend anything with 10 or fewer in stock"); a WEIGHT re-ranks them without hiding them ("de-emphasise low stock"). Reach for a weight whenever the ask is to show something less rather than not at all. For a cart slot, cart_gap prefers (or requires) items priced to close the gap to the cart's next offer threshold (free shipping, a gift, a tier). Call list_catalog_filter_fields first so field names are real. Use list_products to find product IDs.

Create a new campaign with a brief (objective, offer, tone, themes).

Create a draft test of one or more component placements against the unchanged page. With only placement_id it is the classic 50/50 test; additional_placement_ids adds further treatment arms (C, D, ...) so one visitor is drawn into exactly one of: unchanged page, treatment B, treatment C... with an equal fixed split. Every additional placement must sit on the same page pattern, anchor selector, audience and schedule as placement_id (otherwise 409 treatment_*_mismatch) and keeps its own placement row; a placement already in an open test is refused. Starting freezes each arm's revision, binding and audience; assignment is sticky per visitor across all arms. Requires migration 350 for more than one treatment (503 multi_treatment_unavailable otherwise). Cross-site super-admin callers must pass site_id from get_account_status; site-scoped callers stay on their own site.

Create a DRAFT component placement. For between, both anchors must be adjacent siblings. Preview and approve the revision before activation. Cross-site super-admin callers must pass site_id from get_account_status; site-scoped callers stay on their own site.

Create a DRAFT fixed-split test over existing content variants in one zone that all target the same audience segment (the all-visitors segment = everyone, independent of segment ranking). include_control adds an Original arm (the page as-is, arm A) that still records exposures. Allocation is visitor-sticky and never moved by the optimizer; while running, eligible visitors always get their drawn arm. One open test per zone. Nothing serves until update_content_experiment action=start.

Create a personalized content variant for a zone + segment combination. For copy_swap/hero_swap, check the zone's field_schema (get_zones) FIRST and key the payload by its payload_key/canonical_name entries — a payload sharing NO renderable key with a schema-bearing zone binds nothing and is refused with a 400 naming the accepted keys. Do not copy another variant's payload shape without checking the target zone's schema. For product_reco variants, create with an empty payload ({}) and then call configure_product_reco to set the recommendation mode and curated products.

Create a reusable lead-capture form template. The payload is the form design; it is copied onto each placement.

Create a page-level layout experiment as a DRAFT. SIDE EFFECTS: inserts the experiment row, one layout-role zone for the container (page_pattern + element_selector) and an INACTIVE control variant for arm "A" ("Original"); nothing serves to visitors — a draft has no alternative layouts yet and cannot run or pause. Adding fragment arms (including the AI-generated arm B), extra containers, and starting the test are dashboard actions today. element_selector must be a CSS selector for the container (max 300 chars, no <>{ }); page_pattern must start with "/". Requires the layout_experiments module.

Create an offer in this site's library. It is ALWAYS created as an UNAPPROVED DRAFT: a human must ratify it in the dashboard (approve the terms, and attest the code exists and is active in their commerce platform) before it can ever serve. There is no `status` argument here and no tool on any surface that can make an offer live — that transition is dashboard-only, by construction. MONEY IS CENTS AND PERCENTS ARE BASIS POINTS, integers only: value_bp 2500 = 25% off, value_cents 1000 = $10 off. The write is REJECTED when the depth exceeds the site's max_discount_pct ceiling, or when it meets/exceeds the site's gross margin (every order at that depth loses money and no conversion lift can fix it). `code` must be a discount code the merchant's platform ALREADY honors — fulfillment_mode accepts only "existing_code". Returns { id, warnings }; warnings cover mirrored terms and the break-even lift this discount needs. Then place it with place_offer.

Create a page type configuration for sitemap analysis.

Create a link a client or stakeholder can open, without logging in, to review one audience's view of the site on the real storefront: the private working copy (view "draft", the default) or exactly what visitors see (view "live"; ordinary auto-site links show live content; placement_id plus expected_version instead freezes one saved placement on either site mode). The link carries only that audience's content. Returns the URL to send. The link expires on its own (7 days by default, 30 at most) and can be turned off with revoke_preview_share_link. Pass a site-relative path to open on a specific page and a short label so the link is recognisable in the dashboard's list.

Create a new triggered message. Requires name, mode (immediate|dormancy), watch_event, and at least one destination.

Create a new site-owned payload template for triggered messages.

Create a new personalization zone on the site. For lightbox zones (zone_key="lightbox"), pass display_rules to set when/where/who/how-often the popup fires — including country targeting (audience.country) and day/hour windows (schedule); otherwise call list_lightbox_presets and use one of those rule objects verbatim.

Delete a campaign permanently.

Remove a placement without deleting the reusable component. Cross-site super-admin callers must pass site_id from get_account_status; site-scoped callers stay on their own site.

Soft-delete a content variant. The variant is hidden immediately but recoverable via restore_content_variant within 30 days. A history snapshot is automatically created before deletion.

Delete a form template. Already-deployed placements are unaffected (placements copy the payload).

Soft-delete an offer. It vanishes from list_offers and stops being hydrated on the next config build, but the row survives so historical per-offer lift stays attributable. Its PLACEMENTS are deliberately not deleted: they keep their offer_id, hydrate to nothing, and are dropped from tag config, so the page shows no half-resolved offer rather than a stale code — fail closed. If a slot should now carry something else, remove or repoint the placement yourself with delete_content_variant.

Delete a page type configuration.

Permanently delete a trigger and its fire history.

Delete a site-owned trigger payload template.

Delete a zone and all its content variants.

Remove a component from a campaign's manifest. Clears the variant/trigger serving-path campaign_id only when it points at THIS campaign (this is also how a variant linked from the content editor is removed). Live content needs confirm_serving_change. 404 when the pair is not attached. Does not delete the referenced resource. Any change voids an approval.

Use AI to generate a content variant draft for a segment + zone. Returns suggested headline, body, and CTA.

Create a new PLANNING campaign from an existing one (usually a closed one). Copies the brief (as the copy's revision 1), audience eligibility, priority, owner, the goal (only if still active) and the name (with ' (copy)' unless you pass name), and re-references its pages, offers and audiences. Does NOT copy variants or triggers (each serves under one campaign at a time - duplicate those and attach the copies), experiments (tied to the run that measured them) or ad platform campaigns; each comes back in skipped with the reason. Dates are cleared and nothing serves until the copy is approved and launched. The source campaign is untouched.

End a layout experiment — IRREVERSIBLE: an ended experiment can NEVER be restarted (create a new one instead), every arm's variants are deactivated in the same call so visitors immediately see the original layout again, and the results window freezes at ended_at. The transition (with your reason and optional winner_arm_key) is appended to the experiment's history, and the workspace is notified (bell row + same-day email). winner_arm_key here only RECORDS the outcome — it does not keep that arm serving; to end AND keep the winning layout live for everyone, use ship_layout_winner instead. Check get_layout_experiment_results first and do not end a test that is still `collecting` unless the operator asked for it.

One campaign with its MANIFEST (#2198): every attached component (page, variant, trigger, offer, audience, experiment, provider_campaign) with `state` resolved from the referenced resource on this read - missing | draft | ready | live | stopped | failed - plus a `reason`, and `readiness` (ready, goal, required_total/required_satisfied, missing[], live[], stopped[], notes[]). `lifecycle` (planning -> ready -> approved; launched/paused/closed arrive with later phases) is the unit-of-work state and is SEPARATE from `status` (draft/active/ended), the serving gate driven by the flight window; readiness.notes says when the two disagree. Also returns the legacy `content` and `triggers` arrays (the FK-linked view).

Preflight for launch_campaign, with NO writes: whether the campaign can launch (or resume, if paused), the blockers, and per-component steps - which approved pages would be published, which variants would be published on a manual-publishing site, which paused experiments would restart, and what needs an operator (an approved-but-not-live offer: agents cannot set offers live) or is reference-only (ad platform campaigns). Call this and show the operator before launch_campaign.

Read a component test: status, version, history and `arms` in allocation order - arm A is the unchanged-page control, B the first treatment placement, C+ any additional treatment placements (each keeps its own placement id, pinned component revision and equal weight). Cross-site super-admin callers must pass site_id from get_account_status; site-scoped callers stay on their own site.

Read one component placement, including its exact revision, customizations, anchors, targeting and concurrency version. Cross-site super-admin callers must pass site_id from get_account_status; site-scoped callers stay on their own site.

Read one content test: audience, arms (variant per arm, effective weight, Original control if any), split, status, version and history.

One layout experiment in full: status, hypothesis, traffic split, covered zones (page_pattern + element_selector per container), every arm (control "A" plus fragment arms, each with per-zone variants, fragment metadata and impressions), schedule (ends_at), auto_stop and CWV guardrail settings, stop_reason, winner_arm_key — and `history`: every status transition with its timestamp, from/to, reason (manual | scheduled | significance | guardrail:<metric>:<arm>) and actor (user | scheduler | guardrail | api), plus winner/shipped flags, so "why did this test stop?" is always answerable from this one call. For the per-arm conversion/lift numbers use get_layout_experiment_results. Read-only.

RAW multi-armed bandit state: per-arm Thompson Sampling allocation weights, impressions, conversions and Beta posterior params (alpha/beta, expected_reward). READ THE GATES BEFORE COMPARING: every arm carries cvr_ci95 (95% Wilson interval on its observed rate) and `sufficient` (impressions at/above the scorecard's shared per-variant floor), and the response carries a top-level `warning` naming how many arms are below it. A 40-impression arm will regularly out-"score" a 4,000-impression arm by pure noise — never rank or declare winners across arms whose intervals overlap or whose sufficient flag is false, and never report expected_reward as a measured conversion rate (it is a posterior mean that includes the prior). These numbers refresh continuously: re-reading until a comparison looks decisive is peeking and inflates false positives. For the causal "is it working" verdict use get_scorecard.

Get full trigger configuration: events, dormancy, identifier type, destinations, payload templates.

Get full details of a trigger payload template.

Get personalization zones. Pass zone_id to fetch a single zone (recommended when working on a specific zone — full response is 200KB+). Without zone_id, returns all zones for the site. Every zone carries `lifecycle`: `state` is whether it serves right now — live, test_arm (a serving arm of a running content, layout or component test; `experiment` names it, and `also_live_outside_test` says it serves plain content too), paused (everything in it is switched off or ended, or the zone itself is switched off while it holds published content) or draft (empty, nothing published yet, or not approved with nothing published) — plus a plain `summary`. Read the state from this field, never from the zone name: names like "DRAFT ·" or "LIVE ·" are free text and go stale. null means the state could not be read.

Install a lifecycle recipe as a trigger on this site. AXO builds the lifecycle event and shapes it for each destination; no payload template is needed. The trigger is created switched off unless enabled is true. Marketing Cloud Engagement destinations need mapping.event_definition_key unless the integration already has one.

Launch an APPROVED campaign (or resume a PAUSED one) as a durable job. Turns visitors-facing content ON: publishes approved pages, publishes live variants on manual-publishing sites, restarts experiments a pause stopped, then sets the campaign's serving gate active so linked variants and triggers serve inside the flight window. Refused (409 with details.plan) unless approved/paused and the manifest is ready. When approval is required, an unapproved campaign cannot launch (approval_required); submit it via request_review first. Idempotent and deduped per campaign: a retry or a second agent gets the same job, and completed steps are skipped. Returns the job – if status is queued/running, poll get_job. Never sets offers live and never enables ad platform campaigns (reported as needs_operator / reference_only). Confirm with the operator first; call get_campaign_launch_plan to show what will happen.

List pending ad-theme suggestions for the current site before approving or rejecting them.

List all campaigns for the site with status and briefs. To page through a long list, pass `limit`: the response then carries `next_cursor` — pass it back as `cursor` to continue, until it is null. Cursored pages are ordered newest-created first (not active-first).

List controlled component tests and lifecycle state. Cross-site super-admin callers must pass site_id from get_account_status; site-scoped callers stay on their own site.

Read previous full placement bindings, revisions, audiences and schedules for rollback. Cross-site super-admin callers must pass site_id from get_account_status; site-scoped callers stay on their own site.

List component placements with anchors, pinned revision, audience, active state and concurrency version. Cross-site super-admin callers must pass site_id from get_account_status; site-scoped callers stay on their own site.

List fixed-split content tests (A/B/n of ordinary hero/copy/offer variants) and their lifecycle state. Optional zone_id / status filters.

List the published revisions of a content variant, newest first, plus which one is currently published. A revision is a publish act (what visitors saw); get_content_history is the per-save audit trail of the working copy. Cross-site super-admin callers must pass site_id from get_account_status; site-scoped callers stay on their own site.

List reusable lead-capture form templates for this site. Each has a name and a payload (title, cta_text, tcpa_text, success_text, accent_color, fields[], calendar_enabled).

List the site's layout experiments — page-level A/B tests of whole containers (header, hero, grid, footer), each testing the original layout (control arm "A") against one or more alternative-layout fragment arms. Returns per experiment: id, name, status (draft | running | paused | ended), page_type, covered zones, arms with allocation weight and impressions, schedule (ends_at), auto_stop and Core Web Vitals guardrail settings, stop_reason and winner_arm_key. Pass page_type to scope to one page type. Pass include_results: true to attach each non-draft experiment's per-arm real-exposure results inline (same readout as get_layout_experiment_results; draft experiments get results: null) — the Scorecard's "Layout tests" view in one call. Read-only.

List the ready-made lifecycle recipes (abandoned cart, abandoned browse, abandoned checkout, high-intent return, lapsed visitor). Each entry gives the event it watches, the settings a site may change with their bounds, and the integration types it can deliver to (klaviyo, braze, sfmc, webhook, custom).

List the canned lightbox display-rule presets (Welcome offer, Exit intent newsletter, Cart recovery, Promo bar, Returning visitor offer). Each preset returns a complete DisplayRules object that can be passed verbatim as create_zone.display_rules or update_zone.display_rules. Use this instead of authoring the rules JSON from scratch unless you need a custom combination.

List this site's offer library plus the guardrail dials every offer write is validated against. Returns each non-deleted offer (name, status, offer_type, value_bp / value_cents, code, validity window, stacking, approved, code_verified_at), `site_dials` (max_discount_pct — the hard depth ceiling; gross_margin_pct — null when the operator has not configured one), and a per-offer `break_even` hint: the relative conversion lift the discount must produce just to pay for itself (d / (m - d)), null when no margin rate is set. Call this before authoring or placing anything — it is how you tell a ratified, servable offer (status "live" AND approved AND code_verified_at) from a draft that will render nothing. AXO is a SHADOW promo layer: these rows REFERENCE a discount code the merchant's own platform already honors; we never mint one and never touch redemption accounting.

List page type configurations (product, category, blog).

List this site's client review links (newest first) with status (active, expired, revoked), audience, view, page, expiry and whether they have been opened. Pass zone_id to narrow to one zone.

List approval requests for the current site across workflow states.

Get the audit log of fire attempts for a trigger: successes, errors, skipped fires with skip_reason. Paginated: the response carries `next_cursor` — pass it back as `cursor` to continue, until it is null.

List available payload templates: system seeds and site-owned custom templates.

List all triggered messages for the site with watch event, mode, destinations, and enabled status.

Pause a LAUNCHED campaign as a durable job. Immediately stops every variant and trigger linked to the campaign (serving gate off) and pauses its running experiments (never ends them). Does NOT retire published pages and does NOT pause ad platform campaigns - both come back as needs_operator so you can tell the operator exactly what is still running. Reversible with launch_campaign. Idempotent: pausing a paused campaign runs again to finish anything an interrupted pause left running, and job.result.outcome is pause_completed (it paused something) or already_paused (nothing left).

Pause a component placement; insertion is removed or original content restored on the next config reconciliation. Cross-site super-admin callers must pass site_id from get_account_status; site-scoped callers stay on their own site.

Deploy a lead-capture form onto a page: creates a lead_form content variant bound to a zone (anchor) + audience. The form INSERTS relative to the anchor by `position` (default "after" — slots between sections without taking over). Target ONE segment via `segment_id`, OR set `all_visitors: true` to show the form to EVERYONE regardless of segment (provide exactly one). Get a payload from list_forms (copy-on-place) or pass one directly. To anchor somewhere that is not yet a zone, use AXO skills with browser access to inspect the page and bind the anchor with create_zone first.

Deploy an offer into a zone: creates a type="offer" content variant bound to a zone + audience. Target ONE segment via `segment_id`, OR set `all_visitors: true` to show it to EVERYONE regardless of segment (provide exactly one). The placement stores ONLY the offer_id plus presentation overrides — the economics (value, code, window, terms) are joined in from the offer row on every config build, which is what makes an offer ending at midnight go dark everywhere instead of leaving a stale code on the page. The renderer writes into the anchor zone's element, so pick a zone whose contents the offer should own (create_zone first if none exists). Two DIFFERENT offers cannot compete in one zone + audience and the write is rejected if you try: the optimizer ranks on conversion rate, so given a choice of depths it always crowns the deepest one and reports the lost margin as a win — competing arms must share one offer and vary only presentation. Placing an unapproved or non-live offer succeeds but serves nothing until a human ratifies it in the dashboard; check status/approved via list_offers first.

Compile an isolated component preview, optionally with placement-specific field values. Returns HTML and hash without saving or publishing; use the Content page picker for host-page anchor validation. Cross-site super-admin callers must pass site_id from get_account_status; site-scoped callers stay on their own site.

PUBLISH the working copy of one or more content variants so visitors see it: snapshots each into an immutable revision and moves its published pointer. All ids must be live variants of this site or nothing is published. On an auto-publishing site (the default) visitors already see the working copy, so this only records a restore point. Read GET /api/content first: has_unpublished_changes tells you which variants have pending edits on a manual site. When content approval is required, publishing unapproved changes returns approval_required; call request_review first to submit for approval.

Reject a pending ad-theme suggestion for this site.

Update only the listed placements to an approved revision. Returns individual success/conflict results; never assume a partial release was atomic. Cross-site super-admin callers must pass site_id from get_account_status; site-scoped callers stay on their own site.

Change only a placement's name, everywhere it is shown, without saving a new version or re-publishing. Content, targeting, activation and test assignment stay as they are, so it works on a live placement and on an arm of a running component test. Read expected_version first; a mismatch returns 409. Cross-site super-admin callers must pass site_id from get_account_status; site-scoped callers stay on their own site.

Submit one or more items (variants, placements, pages, campaigns) for human review and approval. When approval is required by workspace policy, changes cannot go live directly and must be submitted through this tool first. Approvers are notified to review in the dashboard or via connected channels.

Restore a previous full placement binding as a new private draft. Preview and explicitly publish to change delivery. Cross-site super-admin callers must pass site_id from get_account_status; site-scoped callers stay on their own site.

Restore a content variant. Two modes: (1) pass only variant_id to un-delete a soft-deleted variant; (2) also pass version to roll back the payload to a specific historical version (use get_content_history to find version numbers). Restoring to a version is itself snapshotted, so you can always roll forward again.

Copy a published revision back into the variant's WORKING COPY. The current state is snapshotted into the variant's history first. On an auto-publishing site the working copy is what visitors see, so it takes effect at once; on a manual site it becomes pending edits to preview and then publish. Component placements and routed variants are refused: restore those with restore_content_variant, which re-validates them.

Turn a client review link off immediately. The row is kept for the audit trail; anyone opening the link sees that it was turned off. Use list_preview_share_links to find codes.

Stage a campaign: planning -> ready -> approved (and back). `ready` and `approved` are REFUSED (409, with `details.readiness`) until the manifest is ready: an active goal, at least one required component, every required component ready/live. `approved` pins approved_revision to the latest brief version; a later brief edit voids it (the campaign drops back to ready). launched / paused / closed are refused here - use launch_campaign / pause_campaign / close_campaign. Never writes `status` (the serving gate).

End a layout experiment AND ship the winning layout: the winning fragment arm's variants STAY ACTIVE and serve to 100% of visitors through the ordinary variant path (the always-on holdout keeps measuring them), while every other arm's variants — the control included — are retired. IRREVERSIBLE as a test: the experiment is ended, can never be restarted, and its results freeze at ended_at; the ship is recorded in history (shipped: true) and the workspace is notified. winner_arm_key must name one of the test's FRAGMENT arms — shipping the control is meaningless (that is just end_layout_experiment: naming the control here ends the test WITHOUT shipping anything). Before shipping, read get_layout_experiment_results: do not ship while `collecting` is true, while a guardrail breach stands against the winner, or when the winner is not significant, unless the operator explicitly accepts that.

Return the segment-aware donation ask ladder for a donor — the amounts a fundraising form should show first, plus the recurrence default + rationale. Pass `segment_suffix` for the default ladder per segment (e.g. "donor_ready", "high_capacity_uncontacted", "lapsed_quarterly"), OR pass `profile_id` to personalise off the donor's CRM-fed attributes (last_gift_amount_cents / recurring_amount_cents / lifetime_giving_cents / capacity_score). When `profile_id` is given without `segment_suffix`, the profile's current segment is used. Returns { ladder: { amounts_cents, recurrence, rationale, highlight_index?, highlight_label? }, resolved }. Amounts are in CENTS. Use before authoring a copy_swap variant that writes the amounts onto a donation form, or when the agent needs to suggest "what should we ask for" from the donor context.

Read-only. Suggested "Built for goal" values for this site's placements (content zones and component placements) that have no goal set. Rules: an email or lead-form placement, or a sign-up call to action (zone key or name says signup, email, newsletter or enews, or the zone holds a lead form), maps to the site's matching form, email or newsletter goal; on an affiliate site, a placement whose live content shows product picks, a comparison or a product list (a product recommendation, a list of two or more products or links, or a picks or comparison name), or holds affiliate links or two or more links to other sites, maps to the affiliate click goal; headline, hero and copy zones never qualify on their name or the site vertical; anything else gets no suggestion. Only live placements are considered: drafts, paused and unapproved zones get none. Returns { suggestions: [{ zone_id, placement_id, kind ("zone" | "component_placement"), name, page_pattern, goal {id, name, kind}, rule ("signup" | "affiliate"), reason }], goals, affiliate_site, can_accept }. Nothing is written: show the suggestions to the owner and, only after they agree, accept each with update_zone {zone_id, goal_id} (that works for component placement zones too). can_accept false means goals cannot be saved on this database yet.

Fire a trigger against a test target, bypassing cooldown/rate limits. Goes through the real dispatch pipeline — WILL send real email/SMS. A lifecycle trigger (installed from a recipe) takes only identifier {type: email, phone or external_id, value} and is a dry run that returns the exact payload for each destination; pass dry_run: false to send it. Test fires stay out of lift.

Update a campaign name, brief, status, goal or owner. A brief edit on an APPROVED campaign voids the approval (lifecycle drops to ready; response carries approval_cleared:true). status can only be changed while the campaign is planning or ready; from approved on it is controlled by launch_campaign / pause_campaign (409 otherwise).

Start, pause or end a controlled component test, or add a treatment to a DRAFT one. ship=A keeps the unchanged page; ship=<treatment key> (B, C, ...) releases that treatment to everyone eligible and hides the others; no ship restores each placement's pre-test state. action=add_treatment with placement_id attaches the next arm (same page, anchor, audience and schedule as the first treatment) and is refused once the test has started: adding an arm would re-slice the equal split under visitors already assigned, so end the running test and start a fresh one instead. Changes live delivery. Alternatively, omit action and send ends_at (UTC ISO instant or null) and/or auto_stop alone to configure scheduling. Statistical auto-stop and automatic ship settings are recorded but withheld pending evidence qualification. Cross-site super-admin callers must pass site_id from get_account_status; site-scoped callers stay on their own site.

Save a private draft of placement anchors, targeting, schedule or component revision. Visitors retain the published placement. Read expected_version first; publish explicitly after review. goal_id alone sets the placement's built-for goal without a new version or review. Cross-site super-admin callers must pass site_id from get_account_status; site-scoped callers stay on their own site.

Start, pause or end a content test (action), or change its name/hypothesis/split (no action). Ending with ship=<armKey> keeps that arm live and turns the others off (ship=A with an Original arm restores the page); ending without ship restores each variant's pre-test state. Changing the split on a RUNNING test re-assigns some visitors and restarts the measured window. Requires expected_version (409 on conflict). Changes live delivery. When content approval is required, starting a test with unapproved arm content returns approval_required; call request_review first. Alternatively, omit action and send ends_at (UTC ISO instant or null) and/or auto_stop alone to configure scheduling. Statistical auto-stop and automatic ship settings are recorded but withheld pending evidence qualification.

Update a content variant payload or active status. A history snapshot of the previous state is automatically saved before the update, so changes are always reversible via restore_content_variant. When replacing a copy_swap/hero_swap payload, read-modify-write against the zone's field_schema keys — a re-keyed payload sharing NO renderable key with the zone is refused with a 400 naming the accepted keys.

Update a form template name and/or payload.

Update an offer's terms, or move it between draft / paused / archived. `status` accepts ONLY those three. "live" is a dashboard-only transition gated on human approval plus code verification, and it is refused outright on the API-key path that every agent surface authenticates with — so you CAN pause or archive an offer that is misbehaving, and you CANNOT start one. Ask the operator to approve it in the dashboard instead. Editing the economics (offer_type, value_bp, value_cents, currency, tiers, gift_sku, code) UN-RATIFIES the offer and it stops serving until a human re-approves: approval attaches to specific terms, not to a row id, so a 10%-off offer approved yesterday can never silently become 40% off today — the response reports `approval_reset`. Changing `code` also clears the code verification. Same units and guardrails as create_offer (cents, basis points, the site depth ceiling, the margin floor). OMITTING a field leaves it untouched; sending it as NULL REMOVES it, which is how you make a promo open-ended (ends_at: null = runs indefinitely) or drop a threshold, a cap or a link. Only starts_at, ends_at, min_order_cents, max_discount_cents, max_exposures_per_visitor, code, redeem_url and terms_url accept null — null on anything else is rejected rather than ignored, so a mistaken null never silently no-ops. The response echoes what you removed as `cleared`.

Update a page type configuration.

Update an existing trigger. Pass only the fields to change.

Update a site-owned trigger payload template.

Update an existing zone (selector, name, priority, approval, built-for goal, display_rules, or field schema). To add a missing field (e.g. image_url): call get_zones(zone_id) first to read the existing field_schema, then pass the full updated array with the new entry appended.

Approve a specific component revision for use by live placements. Does not itself activate any placement. Cross-site super-admin callers must pass site_id from get_account_status; site-scoped callers stay on their own site.

Approve the revision you reviewed. Pass revision_id from get_page; required for private drafts, including new drafts on published pages. A stale revision is refused. Approval does not publish.