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 control/treatment exposures and subsequent conversions, with sample floors and uncertainty. A failed render is not a treatment exposure.

Read component delivery and click events by placement and revision. Counts represent observed events, not causal conversion lift; preview traffic is excluded.

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 a peek-safe, multiplicity-adjusted verdict. 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>.

Per-arm results of one layout experiment — the exact real-exposure readout the dashboard shows; the stats are computed server-side, never reimplemented. A session counts for an arm only when a personalization_applied event named one of that arm's variants (the bandit's own attribution), never page-pattern-imputed lift. Returns per arm: sessions, conversions, CVR, relative lift vs the control arm, the NAIVE z-test p_value/significant (fixed-horizon, unadjusted — display only, inflated by the hourly sweep's repeated peeking), peek_safe_significant (the always-valid Robbins–Lai verdict at a Bonferroni-adjusted α across the K fragment arms — the only significance auto-stop and winner-shipping act on), a plain-language confidence readout, and field Core Web Vitals p75s (LCP / CLS / INP) of the exposed sessions. Top-level: `comparisons` (K) and `adjusted_for_comparisons` (true when K > 1, i.e. the peek-safe thresholds carry a multiple-comparison adjustment); `collecting` — true while any arm is under the 30-session floor; report "still collecting" and draw NO verdict — and `guardrail`: every fragment arm's vitals judged against the control per the test's thresholds, including any breach (a breach with action "pause" is what guardrail-paused the test; the pause itself is in get_layout_experiment history). When reporting, lead with peek_safe_significant and treat naive-only significance as "trending, not proven". Once the test has ended, the window freezes at ended_at so a shipped winner's later traffic never moves the verdict. 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. 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.

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. `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.

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. Read `causal` (assigned = saw + not rendered, vs held out: the comparison the random holdout supports) for any claim. `engagement` (saw vs held out) is descriptive and flattering, because non-rendering sessions are mostly early exits. Honest nulls: `relative_lift` is null when held out converted zero times. `verdict: insufficient_data` means the sample gate (sessions plus 20 outcomes per arm) is not met, which is not a flat result. `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. The `all_zones` row counts each session once. A sitewide zone ("/*") makes it equal to that zone.

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.

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.

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 after a two-pick (the extension / preview picker gives you source_selector + dest_selector). 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. To preview without persisting on a no-tag site, use the extension demo flow instead.

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. 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 50/50 test of a component placement against the unchanged page. Starting freezes the revision, binding and audience; assignment is sticky.

Create a DRAFT component placement. For between, both anchors must be adjacent siblings. Preview and approve the revision before activation.

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.

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 and its pinned unchanged-page/control and component arms.

Read one component placement, including its exact revision, customizations, anchors, targeting and concurrency version.

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.

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. 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.

Read previous full placement bindings, revisions, audiences and schedules for rollback.

List component placements with anchors, pinned revision, audience, active state and concurrency version.

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.

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 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.

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.

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, call extension_pick_element then 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.

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.

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.

Restore a previous full placement binding as a new private draft. Preview and explicitly publish to change delivery.

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.

Fire a trigger against a test target, bypassing cooldown/rate limits. Goes through the real dispatch pipeline — WILL send real email/SMS.

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. ship=A keeps the unchanged page; ship=B releases the tested component to everyone eligible. Changes live delivery.

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.

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.

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, 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.

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.

Accept a page suggestion: creates an UNPUBLISHED draft page from the proposed brief. Pass amendments to extend the brief. Generate and publish are separate steps.

Create a draft reusable component from a description or sanitized HTML/CSS. Does not place or publish it.

Create a draft page from an operator-stated goal (no suggestion needed). target is the question the page must answer. Returns the draft; call generate_page next.

Route the right visitor to a published axo Page: creates an entry-point variant (copy_swap/hero_swap) whose CTA the server points at the page (<pageUrl>?vt_route=<variantId> — the attribution join key; never supply URL fields yourself). Rides the full variant machinery: campaign flight window + audience AND-composition via campaign_id, eligibility/segment targeting, priority, per-visitor holdout, lift. Called WITHOUT zone_id it returns needs_zone with candidate zones — pick the one whose page_pattern covers where the audience lands (only zones whose schema carries a url field can host a route). An approved-but-unpublished destination is allowed only with active=false (the suggestion-loop shape); publishing the page re-stamps the href.

Delete a reusable component after its active placements have been resolved. Historical attribution is retained.

Dismiss a page suggestion. The underlying gap stays quiet for the cool-off window.

Duplicate a component into a separate draft so it can evolve independently.

Refine a component with a natural-language instruction using its current revision and site brand. Saves a draft revision without changing live placements. Costs AI budget.

Generate an on-brand HTML/CSS component revision from its brief. Costs AI budget; wait for completion. A conflicting version or generation in flight must be resolved by reading get_component before retrying.

Render a revision of a page from its brief. SLOW: takes 60-120s or more — wait for it. With feedback, regenerates applying it — feedback accumulates, so every regeneration honors all prior feedback. Returns the preview URL. Costs AI budget. A 409 generation_in_flight means a render is already running: do NOT retry — poll get_page for a new revision; if none appears within 6 minutes the lease has expired and one retry is safe. Prefer async=true when your client cannot hold a long call open (many MCP clients time out at 60s): the render is queued as a job and this call returns a job id immediately — poll get_job until it succeeds, then get_page has the new revision. Submitting again while the job is open returns the SAME job (never a second paid render).

Read a component with immutable revision history and all placements. Draft edits never change a live placement.

Get content variants. Pass zone_id to fetch only variants for a single zone (recommended — the full response is 1MB+). Without zone_id, returns all variants for the site. To page through a large catalog instead, 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 grouped by zone).

Get the version history for a content variant. Returns up to 20 snapshots ordered newest first, each with version number, who changed it (changed_by: an agent token as mcp_token:<id>, a user as user:<id>, or the legacy api/dashboard values, plus a resolved changed_by_label like the token name or user email), when, and the full payload. Use this before calling restore to find the version you want.

One page in full: brief, revision history, publications, shareable preview URL (pre-publish, noindex) and the public URL when published.

The OBSERVED route funnel per route (shown → routed_sessions via vt_route → destination conversions), descriptive not causal — filter by variant_id or campaign_id (the campaign rollup), days 1-90 (default 30). For the CAUSAL number use get_variant_performance: a route is an ordinary variant to the holdout lift lane.

Import a design into axo from a publicly fetchable URL. The file is a self-contained HTML bundle with all images, fonts, and styles inlined.