Spreng MCP

Appearance

Tool catalog ​

Auto-generated from the current advertised source registry. 94 tools across 8 groups. Last regenerated: 2026-08-15.

How tier gating works

Tools are tagged with the minimum subscription tier required. Admin role bypasses all gates. The MCP server returns a clear error before forwarding the call if your tier doesn't qualify.

Strategist (orchestration) ​

ToolCostTierDescription
decide_creative_strategy40 crStarter⭐ START HERE for any 'make me ads / a campaign for this offer' request. Given a brief (offer, audience, goal, budget) this acts as the creative strategist and decides the optimal mix of formats (image
generate_complete_campaign—Starter⭐ The one-call way to produce an ENTIRE campaign. Give it a brief (or a manifest from decide_creative_strategy) and it plans the format mix AND generates everything — images, videos, copy, emails — in

decide_creative_strategy ​

⭐ START HERE for any 'make me ads / a campaign for this offer' request. Given a brief (offer, audience, goal, budget) this acts as the creative strategist and decides the optimal mix of formats (images, videos, copy, emails) — you do NOT need to pick formats or call the individual generate_* tools yourself. Returns a manifest with rationale, angles, per-format counts, and total credit cost. Plan first with this, then pass the manifest to generate_complete_campaign to produce everything. When NOT to use: if the user explicitly wants ONE specific asset (e.g. 'just write ad copy'), call that single generate_* tool directly instead. Cost: 40 credits (one Claude reasoning call). Returns JSON only — no assets generated yet.

Cost: 40 cr · Minimum tier: Starter

Required: brief

Optional: clientId, budgetCredits, preferences, requestDeadlineAt

generate_complete_campaign ​

⭐ The one-call way to produce an ENTIRE campaign. Give it a brief (or a manifest from decide_creative_strategy) and it plans the format mix AND generates everything — images, videos, copy, emails — in parallel (concurrency=3). Copy assets are scored by an advisory QA critique and ship with that score attached (one generation each — nothing is regenerated on a low score). This is the primary entry point for 'make me a full set of ads/creatives'; you do NOT need to orchestrate the individual generate_* tools yourself. If you pass brief it auto-runs the strategist first (+40 cr); pass a pre-decided manifest to skip that. A call accepts at most 12 total tasks and 3 request-bound tasks; durable video children return pollable job receipts, and narration-based formats require an approved script so a campaign brief is never spoken verbatim. When NOT to use: for a single asset, call that one generate_* tool directly. Returns { strategy, campaign: { children, failures, successRate } }. Async children return jobIds — poll check_generation_status. Total cost: sum of child costs (+40 cr if auto-planned).

Cost: — · Minimum tier: Starter

Required: clientId, businessName, promptContext, clientRequestId

Optional: brief, manifest, budgetCredits, offerName, angle, angleId, angleRef, expectedAngleText, highTicketOffer, audienceResearch, notes, script, narrationScript

Image creative ​

ToolCostTierDescription
generate_ad_image—StarterGenerate prompt-plate/template ad images for an offer. ASYNC — returns a jobId immediately; poll check_generation_status with this jobId every 2-3 seconds until status='completed', then read the compl
generate_image_variations—StarterGenerate controlled variations of an existing ad image — riff on a winner across hooks, angles, audiences, concepts, creative refreshes, styles, or sizes without starting from scratch. Each image is g
analyze_ad_image20 crStarterScore an existing ad image for quality / compliance / persuasiveness using Gemini vision. Pass an image URL (the tool fetches and base64-encodes it for you). Returns

generate_ad_image ​

Generate prompt-plate/template ad images for an offer. ASYNC — returns a jobId immediately; poll check_generation_status with this jobId every 2-3 seconds until status='completed', then read the completed task/gallery for image URLs. IMPORTANT MCP FLOW: for app-like Template Ads / Best Fit Ads, call prepare_image_ads FIRST to select one saved messaging angle and the best-fit prompt plates, then pass its suggestedCall.arguments here. Pass selectedPrompts for specific prompt plates; only omit them for a quick generic starter batch. Cost: from 110 credits per image (the registry floor; a dearer model bills more).

Cost: — · Minimum tier: Starter

Required: promptContext, businessName, offerName, clientId

Optional: imageUrl, referenceImages, imageConcept, model, imageSize, selectedAngle, selectedAngleId, avoidAiPeople, contextDepth, proofHeavy, useAvatar, avatarProfileId, personCasting, selectedPrompts

generate_image_variations ​

Generate controlled variations of an existing ad image — riff on a winner across hooks, angles, audiences, concepts, creative refreshes, styles, or sizes without starting from scratch. Each image is generated from an explicit variation strategy card. ASYNC — returns jobId; poll check_generation_status with jobType='ad-images'. From MCP chat, call prepare_image_ads with surface='variations' first when you need the correct client angle/context and a complete suggested call. Cost: from 110 credits per delivered image.

Cost: — · Minimum tier: Starter

Required: originalImageUrl, clientId

Optional: variationType, count, originalConcept, promptContext, businessName, userNotes, angleId, expectedAngleText, imageSize, aiModel

analyze_ad_image ​

Score an existing ad image for quality / compliance / persuasiveness using Gemini vision. Pass an image URL (the tool fetches and base64-encodes it for you). Returns { score, issues[], suggestions[] } — useful as a post-generation QA step before running paid ads, or to evaluate competitor creative. SYNC. Cost: 20 credits.

Cost: 20 cr · Minimum tier: Starter

Required: imageUrl

Video creative ​

ToolCostTierDescription
generate_doodle_vsl—StarterGenerate either a standard animated Doodle VSL or a 24-30 plate illustrated documentary. GPT Image 2 renders the scenes, Kokoro or ElevenLabs narrates, and Remotion composes the video. ASYNC: returns
generate_broll_video180 crStarterGenerate a durable 30-120s ad video with narration laid over context-matched B-roll. The worker checkpoints segmentation, narration, footage selection, generated misses, rendering, and thumbnail deliv
generate_video_reel—StarterStart a durable AI video job from a first-frame image. Three modes: (1) SINGLE 8s reel: pass imageUrl + clientId. (2) EXTENDED REEL: use model='seedance-2' and pass extended=true + targetSeconds (up t
add_video_captions20 crStarterAdd animated captions to an existing generated video that ALREADY has word-level timestamps: a Doodle VSL or a B-roll video produced in this app. Burns one-word-at-a-time captions into the final MP4 u

generate_doodle_vsl ​

Generate either a standard animated Doodle VSL or a 24-30 plate illustrated documentary. GPT Image 2 renders the scenes, Kokoro or ElevenLabs narrates, and Remotion composes the video. ASYNC: returns jobId; poll check_generation_status with jobType='doodle-vsl'. Cost: 1,700 credits for the standard animated Doodle VSL, or from 1,500 credits for the illustrated documentary, which is billed dynamically.

Cost: — · Minimum tier: Starter

Required: script, clientId, clientRequestId

Optional: mode, voiceId, narrationEngine, selectedAngle, selectedAngleId, visualGuidance, title, aspectRatio, animationStyle, method, doodleStyle, artModel, styleId, textMode, layout

generate_broll_video ​

Generate a durable 30-120s ad video with narration laid over context-matched B-roll. The worker checkpoints segmentation, narration, footage selection, generated misses, rendering, and thumbnail delivery, so a request can recover across function timeouts. ASYNC — returns the public broll_videos jobId for check_generation_status plus workerJobId. Cost: 180 credits.

Cost: 180 cr · Minimum tier: Starter

Required: script, clientId, clientRequestId

Optional: voiceId, narrationEngine, messagingAngle, messagingAngleId, aspectRatio, duration, previewOnly, visualGuidance, footageSteer

generate_video_reel ​

Start a durable AI video job from a first-frame image. Three modes: (1) SINGLE 8s reel: pass imageUrl + clientId. (2) EXTENDED REEL: use model='seedance-2' and pass extended=true + targetSeconds (up to 60, at most 4 provider parts); parts are generated, stored, and assembled durably. (3) MULTI-CUT UGC AD (Method C): pass model='kling-3.0' + shots=[2-5 per-cut prompts]; Kling 3.0 returns ONE multi-cut talking-head video in a single call, holding the actor across cuts. The imageUrl is the first frame / AI actor (generate it first with generate_ad_image for a UGC actor). Extended and multi-cut modes cannot be combined. ASYNC: returns a stable jobId; poll check_generation_status with jobType='ai-reels'. Pass a stable clientRequestId when retrying an ambiguous start so it cannot duplicate paid work. Cost: from 1,050 credits per reel job.

Cost: — · Minimum tier: Starter

Required: clientId, imageUrl, clientRequestId

Optional: model, shots, extended, targetSeconds, maxParts, captions, customPrompt, imageConcept, selectedAngle, selectedAngleId

add_video_captions ​

Add animated captions to an existing generated video that ALREADY has word-level timestamps: a Doodle VSL or a B-roll video produced in this app. Burns one-word-at-a-time captions into the final MP4 using the stored word timestamps. Runs synchronously and returns the captioned URL. Cost: 20 credits. NOTE: only works on a stored doodle/broll record (it needs the saved word timestamps), not an arbitrary MP4 URL.

Cost: 20 cr · Minimum tier: Starter

Required: output_id, output_type

Copy creative ​

ToolCostTierDescription
generate_carousel—StarterRender a multi-slide image carousel ad (3-10 slides). Best flow: first call generate_carousel_copy with persist=false to create/review a carousel_spec, then pass that spec here. If no spec is passed,

Render a multi-slide image carousel ad (3-10 slides). Best flow: first call generate_carousel_copy with persist=false to create/review a carousel_spec, then pass that spec here. If no spec is passed, this renderer will create one internally without saving a separate copy_ready row. Only clientId is required: you MAY supply a template-shaped slideStructure (one entry per slide: position, role, instruction) plus systemPrompt and templateName for explicit control, but if you omit them the renderer auto-plans the slides from the client's offer context. The selected template becomes the copy planner's brief, not stale copy. ASYNC: it returns { success, carouselId } immediately and renders the slide images in the background; poll check_generation_status (or the carousel record) for completion. It returns NO rendered images synchronously. Cost: from 110 credits per rendered slide. Requires clientId. MCP FLOW: call prepare_image_ads with surface='carousel', then call generate_carousel_copy using the suggested call. Review/tweak the returned carousel_spec, then call this renderer.

Cost: — · Minimum tier: Starter

Required: clientId

Optional: slideStructure, systemPrompt, templateName, promptContext, businessName, model, imageSize, slideCount, selectedAngle, selectedAngleId, additionalNotes, mode, carouselFormat, ctaLabel, ctaUrl, textMode, spec, carouselId, action

Intelligence / research ​

ToolCostTierDescription
scrape_offer65 crStarterScrape a competitor's or your own offer page and return structured data: { title, copy, pricing, cta, headlines[] }. Use this before generation tools to ground them in real offer details. SYNC — retur
audience_research660 crStarterRun audience research for an offer — surface pain points, desires, objections, and demographic patterns. Standard uses the grounded light path; Premium uses the async Deep Research agents. Pass market
find_winning_ads25 crProDiscover competitor ads that have been running long enough to be considered 'winning' (still active after N days = passing the spend test). Searches the Facebook Ad Library by keyword, optionally filt

scrape_offer ​

Scrape a competitor's or your own offer page and return structured data: { title, copy, pricing, cta, headlines[] }. Use this before generation tools to ground them in real offer details. SYNC — returns immediately. Cost: 65 credits.

Cost: 65 cr · Minimum tier: Starter

Required: url

audience_research ​

Run audience research for an offer — surface pain points, desires, objections, and demographic patterns. Standard uses the grounded light path; Premium uses the async Deep Research agents. Pass marketingData for action=start, then poll with interactionId or pass clientId so the server persists the report when complete. Cost: 660 credits per run on both tiers; the Premium Deep Research surcharge is charged by analyze_offer, not here.

Cost: 660 cr · Minimum tier: Starter

Optional: marketingData, interactionId, clientId, researchTier, billing

find_winning_ads ​

Discover competitor ads that have been running long enough to be considered 'winning' (still active after N days = passing the spend test). Searches the Facebook Ad Library by keyword, optionally filtered to low-ticket offers. Returns ads with copy, image URLs, days active, and pricing inferences. SYNC. Cost: 25 credits. Tier: Pro.

Cost: 25 cr · Minimum tier: Pro

Required: clientId, keywords

Optional: mode, maxAds, minDaysActive, lowTicketOnly, priceRangeMin, priceRangeMax

Async polling ​

ToolCostTierDescription
check_generation_statusFreeStarterCheck the status of an async generation job. FREE — no credits charged. Returns { status: 'pending'|'processing'|'children_queued'|'completed'|'failed', progress: 0-100, statusMessage, outputId, o

check_generation_status ​

Check the status of an async generation job. FREE — no credits charged. Returns { status: 'pending'|'processing'|'children_queued'|'completed'|'failed', progress: 0-100, statusMessage, outputId, outputTable, error, completedAt }. Recommended poll interval: 2 seconds.

Cost: Free · Minimum tier: Starter

Required: jobId, jobType

Account & workflow ​

ToolCostTierDescription
get_credit_balanceFreeStarterGet the current credit balance for the authenticated organization. Returns { balance, reserved, available, lifetimeGranted, lifetimeUsed }. FREE — no credits charged. Useful as a pre-flight check befo
list_clientsFreeStarterList all clients (saved offer briefs) for the authenticated user. Each client groups a businessName + offerName + research context. Returns [{ id, businessName, offerName, createdAt }]. FREE. Use this
get_clientFreeStarterFetch the full record for a single client by id, including the long-form prompt_context, messaging_angles, audience_research, brand_kit, analysis_status, and other context fields. Companion to list_cl
create_clientFreeStarterCreate a new client (saved offer brief) for the authenticated user. Returns the created client { id, businessName, offerName }. The returned id is the clientId other generation tools require. FREE.

get_credit_balance ​

Get the current credit balance for the authenticated organization. Returns { balance, reserved, available, lifetimeGranted, lifetimeUsed }. FREE — no credits charged. Useful as a pre-flight check before expensive tools like generate_doodle_vsl (price varies by mode and plan).

Cost: Free · Minimum tier: Starter

list_clients ​

List all clients (saved offer briefs) for the authenticated user. Each client groups a businessName + offerName + research context. Returns [{ id, businessName, offerName, createdAt }]. FREE. Use this BEFORE any generation tool that requires a clientId.

Cost: Free · Minimum tier: Starter

Optional: limit

get_client ​

Fetch the full record for a single client by id, including the long-form prompt_context, messaging_angles, audience_research, brand_kit, analysis_status, and other context fields. Companion to list_clients (which returns lightweight previews only). FREE.

Cost: Free · Minimum tier: Starter

Required: clientId

create_client ​

Create a new client (saved offer brief) for the authenticated user. Returns the created client { id, businessName, offerName }. The returned id is the clientId other generation tools require. FREE.

Cost: Free · Minimum tier: Starter

Required: businessName

Optional: offerName, promptContext, sourceUrl

Additional advertised tools ​

ToolCostTierDescription
analyze_offer—StarterStart Spreng's ONE full deep-research pipeline for a confirmed client/offer. This is the MCP equivalent of the app's single 'Confirm & start deep research' button: it pulls online VoC, YouTube/problem
augment_research—StarterRegenerate a client's research artifact + message decision + mechanism + product spec + messaging angles from the EXISTING research PLUS any newly-attached research_documents — WITHOUT re-scraping the
extract_document_text5 crStarterBring-your-own research: extract plain text from an uploaded research DOCUMENT (PDF / txt / md / docx) and ATTACH it to a client's research_documents (the high-trust corpus). Pass the file as a public
create_low_ticket_offer55 crStarterBuild OR formalize a low-ticket offer onto a client. TWO modes: (1) COLD — for a client who does NOT yet have research, give a niche / business idea (and optionally a high-ticket back-end to reverse-e
structure_research690 crProSynthesize the client's raw research corpus into the 28 named, addressable research sections (the structured research artifact) via a flagship model. Run this after audience research / scrape so downs
decide_message80 crProDecide the ONE message for the client's offer (the 8-field message decision: awareness stage, sophistication stage, saturation read, big idea, dominant emotion, positioning, primary angle, proof strat
generate_mechanism75 crStarterBuild or sharpen the client's UNIQUE MECHANISM and emit it as a clean schema (mechanism_name, the_how, the_proof, the_one_line, the_visual_metaphor, believability_check). Runs the 6-step operator (dia
research_to_product75 crStarterThe PRODUCT IDEATION OPERATOR (doc 59): derive a validated low-ticket front-end product spec ($7-$97) FROM the client's buyer research. Runs AFTER the research chain (it reads the research_artifact +
construct_offer75 crStarterThe OFFER OPERATOR (doc 116): construct the full low-ticket OFFER from the client's PRODUCT spec + research. Runs AFTER research_to_product (it reads the latest lt_product_specs row + the research art
grade_offer75 crStarterThe PATH-A GRADER (doc 116 Phase 4): grade the client's EXISTING (scraped) low-ticket offer against the 31 product-marks + 30 offer-marks, then return the UPGRADED offer. Research-first by design: it
construct_stack75 crStarterThe STACK OPERATOR (doc 120): construct the full low-ticket value STACK that wraps the OFFER. Runs AFTER construct_offer (it reads the latest lt_offer_specs row + the latest lt_product_specs + the eco
grade_stack80 crStarterThe PATH-A STACK GRADER (doc 120): grade the client's EXISTING low-ticket STACK against the 30 stack-marks, then return the UPGRADED stack. Research-first by design (requires a research artifact + an
generate_video_series55 crStarterTurn ONE winning UGC video into a SERIES: produce N distinct topic concepts that all use the SAME format but each open a different door into the offer (a different pain, desire, objection, sub-audienc
verify_research55 crProAdversarially verify the client's structured research against its source corpus: returns a per-section confidence + flagged claims (not-in-corpus / marketing-speak / invented-number) + an overall evid
extract_brand_kit20 crProPull the client's visual brand identity (palette, fonts, visual style, logo) from their website via Firecrawl branding evidence plus a rendered vision pass. An initial extraction creates a named kit;
list_brand_kitsFreeStarterList the named Brand Kits saved for one client, including the default selection, current accepted versions, and pending extracted revisions. FREE.
set_default_brand_kitFreeStarterChoose which saved Brand Kit all new visual generations use for a client. The exact accepted kit version is recorded in asset provenance. FREE.
deconstruct_ad25 crProReverse-engineer a winning ad (image and/or copy) into a reusable playbook: hook + hook type, primary angle, format, awareness stage, emotional driver, visual + copy technique, why it works, a what-to
generate_spy_brief10 crStarterSynthesize the client's saved competitor winners into a strategic landscape brief: dominant angles, burned mechanisms, the market sophistication read, the whitespace gap nobody is using, and a concret
update_clientFreeStarterUpdate an existing client's fields. The most important use is setting the GUIDELINES: the client's hard creative rules that MUST appear on every generated ad (e.g. 'always show the price', 'every ad m
generate_product_ads—StarterGenerate product ad images from an uploaded product photo: a vision pass analyzes the product, then each concept is rendered as an ad WITH the real product restaged (studio product still). Nano Banana
generate_product_stack—ProGenerate digital-product mockup images (eBook, course, bundle, etc.) for the offer, on-brand. Cost: from 110 credits per image. Tier: Pro.
generate_product_matrix—StarterGenerate a winner-conditioned, judge-gated PRODUCT-AD MATRIX from ONE product photo: a diverse grid of scene x angle x format x persona cells, each rendered then scored /10 with a verdict before it sh
generate_photo_edit110 crStarterCreate a NEW edited copy of an existing image via gpt-image-2's editing API: ai-cleanup (remove AI artifacts), custom-edit (free-form), or one of the messaging edit types from the photo-edit registry
prepare_image_adsFreeStarterREAD-ONLY planning tool for using Spreng image generation from chat. Mirrors the app's selection step: checks whether the client has research/angles, picks or validates ONE messaging angle, ranks best
creative_strategist_agent120 crStarter⭐ THE CREATIVE STRATEGIST AGENT. Give it a brief (an offer URL or a few lines of context) and a clientId, and it runs the whole low-ticket creative loop for you: UNDERSTAND (scrape the offer + load th
generate_meme_hybrid240 crStarterGenerate a two-panel MEME ad whose panels show the CLIENT'S OWN FACE. Two machines render it: the image model stages each panel's art from the client's saved identity pack and renders NO text at all,
generate_texting_story45 crStarterGenerate an ANIMATED TEXTING STORY ad: a short MP4 of a text-message conversation that TYPES ITSELF OUT (3-dot typing indicators, bubbles dropping in one-by-one, the thread auto-scrolling, holding on
generate_portrait_talking_head—StarterPHOTO -> TALKING HEAD: animate ONE uploaded photo of a REAL person into a lip-synced talking-head video of THAT person speaking your script (for VSLs + Reels/TikTok). Audio is generated with ElevenLab
generate_podcast_ad—StarterGenerate a FAKE PODCAST CLIP ad: a short captioned MP4 of TWO AI 'hosts' on mics in a podcast studio, talking about the offer's problem / mechanism as if overheard (the rising, low-saturation 'eavesdr
generate_before_after250 crStarterGenerate a BEFORE/AFTER TRANSFORMATION video ad: a short MP4 that holds on a problem-state image, wipes (or slides) to reveal the result-state image, then holds on the result, with 'BEFORE'/'AFTER' pi
generate_listicle_ad75 crStarterGenerate a LISTICLE / 'N reasons' TEXT-MOTION video ad: a short MP4 of a kinetic numbered list. A title/hook card shows ('3 reasons I switched...'), then each point animates in one-by-one (number badg
frame_showcase—StarterWrap a completed client video in a Framed Showcase recipe board. The inner video is reused without being generated or billed again. Choose exactly one sourceVideoId from the client's completed video
generate_kinetic_hook45 crStarterGenerate a KINETIC TYPOGRAPHY hook-text video ad: a short MP4 of a punchy scroll-stopping hook delivered as full-screen bold animated text (phrases revealing one-by-one with a spring/scale entrance, o
generate_remix_hook—StarterDurable HOOK REMIX. Keep a winning ad's body (with its old hook removed), create up to six new first-1-3-second hooks, prepend each hook, and save the finished variants to the client's video library.
multiply_winning_hooks—StarterMULTIPLY A WINNING UGC VIDEO INTO N NEW ONES, the hook-multiplication loop. Take a WINNING long-form UGC video you generated (a ugc_video_tasks PROJECT, via taskId), auto-reconstruct its BODY (scene
generate_text_vsl160 crStarterGenerate a premium TEXT-ONLY VSL ad: a short MP4 (≈30-60s) where a voiceover plays over a solid/gradient background and the spoken words appear as LARGE, DYNAMIC kinetic text synced to the voiceover w
generate_whiteboard_comparison170 crStarterGenerate a VOICED 'X vs Y' WHITEBOARD COMPARISON EXPLAINER: a short MP4 drawn in a hand-drawn whiteboard style. The question is written at the top and underlined, two labelled sides are boxed in, a di
generate_vox_explainer390 crStarterGenerate a VOX-STYLE ANIMATED EDITORIAL EXPLAINER: a 30/60/90-second MP4 where a measured voiceover carries the argument and the visuals are real animated editorial graphics — kinetic headlines locked
generate_autocut25 crStarterONE-CALL AUTOCUT: give a clientId + ONE long raw source video URL, get back a finished short captioned vertical clip cut straight out of that footage. Gemini watches the source, picks the best N self-
generate_copyFreeProGenerate written marketing copy for an offer — one tool, five formats via format: 'ad_copy' (5 Facebook ad variations), 'email' (5–7 email launch/nurture sequence), 'vsl_script' (video sales letter)
assemble_ugc_ad110 crStarterAssemble a VOICEOVER-DRIVEN video ad (the B-roll / VSL pattern): stitch N background clips into ONE video with a single locked voiceover over the top + word-timed sound-off captions, exported 9:16 / 4
generate_broll_ad220 crStarterONE-CALL B-roll VSL ad: give a clientId + a script, get back a finished voiceover-driven video ad. It auto-segments the script into scene beats, finds matching stock B-roll per beat, generates one Ele
generate_talking_head_ad—StarterDURABLE talking-head UGC parent: give a clientId, stable clientRequestId, and script, then get a resumable job where ONE AI person speaks the script TO CAMERA with NATIVE lip-synced audio. It generate
generate_hybrid_ad—StarterONE-CALL HYBRID ad: a talking-head HOOK hard-cut into a B-roll BODY. Give a clientId + a short hookScript (what the on-camera person SAYS, ~3-6s) + a bodyScript (the VOICEOVER script for the B-roll bo
add_client_footage15 crStarterAdd a client's OWN video clips to their B-roll footage library, so generate_broll_ad can use them (source='client' or 'mixed'). Pass PUBLIC clip URLs — Google Drive FILE share links, Dropbox links, or
list_client_footageFreeStarterList the clips in a client's uploaded B-roll footage library (added via add_client_footage), with their AI descriptions, tags, and URLs. Use it to see what footage is available before making a client-
clip_client_footageFreeStarterExtract usable B-roll sections out of ONE long video already in a client's footage library. A clip here is an in/out point on the original, NOT a new video file — so every extracted clip is immediatel
list_client_actorsFreeStarterList the saved AI presenters (actors) for a client, the faces previously generated by generate_talking_head_ad. Use it to find an actor to REUSE so the next talking-head ad keeps the same presenter: p
caption_video20 crStarterBurn word-timed captions onto a FINISHED video at a public URL. Transcribes the clip's own audio (no stored word timestamps needed, unlike add_video_captions) and preserves the native sound. Returns t
remix_captions20 crStarterRe-caption an EXISTING generated video with N new caption/hook sets (different text, style, pacing) WITHOUT regenerating the video — the fast way to spin hook variants off one clip. The source is a co
generate_ugc_storyboard—StarterThe DURABLE LONG-FORM UGC orchestrator. action=start takes an edited multi-scene storyboard and AI-generates each scene (Kling multi-shot / Veo / Seedance) with a locked character + voice, then stitch
generate_carousel_copy1 crStarterCAROUSEL (copy-first): decide a whole carousel as COPY first, BEFORE any image is rendered. Plans a carousel_spec { hook_formula, flow_framework, one_offer, primary_cta, slides:[{position, role, headl
generate_video_script—StarterVIDEO SCRIPT (the Stage-1 for any video ad): turn an offer + messaging angle + video type into a hook-first VO script PLUS an editable scene-by-scene plan (one chunk per generated clip). ASYNC: it ret
refresh_angles5 crStarterFind NEW, relevant messaging angles for an offer that's ALREADY running, without discarding the research. Re-pulls FRESH signals (competitor Meta ads via scan-ad-library + fresh Trustpilot/YouTube VoC
synthetic_persona_pretest15 crStarterPRE-TEST the client's saved messaging angles/headlines against a SIMULATED ICP persona panel BEFORE any ad spend. Builds N diverse personas from the offer + audience research, simulates each reacting
refresh_competitor_brand75 crStarterAdd/track a COMPETITOR BRAND and pull its LIVE Meta ads (the brand-centric spy). Pass a brandId to refresh an existing brand, OR clientId + name + (fbPageUrl OR keywords) to create-and-refresh one. Pu
generate_product_mockup110 crStarterPRODUCT STUDIO: manufacture a product image for a DIGITAL / INFO / low-ticket product that has no physical product to photograph (a book, a course-on-a-laptop/tablet/phone, a box, a bundle, a workbook
teardown_winning_video10 crStarterTear a COMPETITOR video ad down into a structured, model-able breakdown. Pass a competitor video URL (from find_winning_ads / the spy board) or raw base64, and Gemini video-understanding returns { for
voice_lock120 crStarterSpeech-to-speech voice-lock: take a HUMAN voice read (source audio that carries the emotion + timing) and re-render it in a TARGET AI voice, preserving the source performance. This is the #1 real-vs-A
relip_video—StarterRe-dub / lip-sync an EXISTING video: take a finished clip + a NEW audio track and re-sync the speaker's MOUTH to that audio (re-voice an ad, dub it to another language, swap the VO). No new pixels are
critique_creative10 crStarterQuality-check generated marketing copy (ad copy, email, VSL script, landing copy, or angles) before it ships. Scores it out of 10 against a direct-response rubric (hook, retention, proof, CTA, native
score_ad20 crStarterScore an AD IMAGE or VIDEO out of 10 before it ships (the Ad Score surface). Images run the visual judge rubric (hook/stopping power, clarity, product prominence, craft, native feel); videos run the v
duplicate_video_ad—StarterDUPLICATE A COMPETITOR VIDEO AD: feed a competitor ad VIDEO; we (1) deconstruct it with Gemini video-understanding into its creative structure + transcript, (2) re-storyboard it with YOUR client's ful
manage_brand_memoryFreeStarterRead and write the client's durable BRAND BRAIN: the learnings that make every future strategy and generation brand-aware. The creative strategist reads this on every run and writes distilled learning
manage_meta_connectionFreeStarterConnect or check a client's Meta ad account via a bring-your-own System User token. The user pastes their OWN non-expiring Meta System User access token with ads_management for the client and picks an
get_meta_insightsFreeStarterRead a connected client's recent Meta ad performance (spend, ROAS, CPA, CTR by ad), the data source for the Agent v3 learn loop. Uses the client's stored bring-your-own System User token (connect it f
meta_launch_preflightFreeStarterRun the real Meta launch dry run for a client's paused campaign build. This creates ZERO Meta objects and spends ZERO budget. It validates the exact preset + selected ads against Meta, checks the conn
meta_launch_campaignFreeStarterLaunch a Meta campaign through Spreng's paused launcher. Fresh launches always create the campaign, ad set, and ads PAUSED. This tool does NOT expose in-app activation. Use action=launch after a passi
meta_launch_statusFreeStarterRead the state of a client's Meta launch without mutating Meta. Use action=list for recent launches, action=get for the normal launch header + item ledger, action=bundle for the full support bundle, o
upload_media_to_metaFreeStarterPush a generated image or video straight to a connected client's Meta ad-account media library (no campaign, ad set, or ad is created). Use it to get an asset into the account so you can attach it to
export_carousel_to_metaFreeStarterPush a FINISHED carousel's cards into the connected client's Meta ad-account media library and get back a READY carousel-ad payload: per-card image hashes + child_attachments (card headline <=45 / des
learn_from_meta_performanceFreeStarterRead a connected client's live Meta performance, pick the genuine winner (best ROAS above a meaningful spend floor), and record it in the client's Brand Brain so the AI strategist learns from what act
manage_support_ticketsFreeStarterCreate, list, reply to, and update Spreng support tickets. Users see their own tickets; admins see all tickets and can reply or set status. This backs the bottom-right in-app support chat and Admin ->
manage_prompt_libraryFreeStarterManage Spreng prompt plates/custom prompts through the MCP. Actions: list_system, list_community, list_library, create_custom, add_community, set_sharing. For generation, prefer prepare_image_ads: it
admin_grant_creditsFreeStarterAdmin-only: grant positive bonus credits to an active organization member. Uses the canonical add_credits RPC through the admin-grant-credits edge function, records a billing audit row, and refuses ne

analyze_offer ​

Start Spreng's ONE full deep-research pipeline for a confirmed client/offer. This is the MCP equivalent of the app's single 'Confirm & start deep research' button: it pulls online VoC, YouTube/problem VoC, landing-page and review/search evidence, competitor ad signals, tiered audience analysis, structured research, verification, message decision, unique mechanism, product/offer specs when relevant, brand kit, and messaging angles. ASYNC: returns immediately and runs in the background. Poll get_client and read analysisStatus.running/currentStep/steps; finished is running=false + done=true. Do not call the child tools separately unless repairing one failed optional step. The client must already have confirmed marketing_data/source_url; call scrape_offer/create_client first if needed. Standard is the default; pass researchTier='premium' to add Deep Research agents and Fusion synthesis. Cost: there is no pipeline-level charge; every step bills its own registry price as it runs, and the heaviest single step is audience research at 660 credits. researchTier='premium' adds a Deep Research surcharge of 600 credits on top.

Cost: — · Minimum tier: Starter

Required: clientId

Optional: businessName, websiteUrl, skipReviews, skipBrand, researchTier, retrySource

augment_research ​

Regenerate a client's research artifact + message decision + mechanism + product spec + messaging angles from the EXISTING research PLUS any newly-attached research_documents — WITHOUT re-scraping the internet. Runs ONLY the synthesis subset of the research chain (structure_research -> verify_research -> decide_message -> generate_mechanism -> research_to_product -> generate_messaging_angles) and SKIPS every pull (reviews / VoC / ad-library / audience). Use this AFTER extract_document_text has attached a document, to fold it in cheaply (~30s, a few credits) instead of a full analyze_offer. ASYNC: returns immediately and runs in the background; poll get_client and read analysis_status (running=false + done=true when finished; result has mode='augment' + researchArtifactId + angleCount). Old artifacts/angles are KEPT (versioned), so it is reversible. Each synthesis step bills its own credit (no pulls => much cheaper than analyze_offer). Cost: no wrapper charge; each synthesis step bills its own registry price, namely structure_research (690 credits), verify_research (55 credits), decide_message (80 credits), generate_mechanism (75 credits), research_to_product (75 credits) and generate_messaging_angles (270 credits).

Cost: — · Minimum tier: Starter

Required: clientId

Optional: researchTier

extract_document_text ​

Bring-your-own research: extract plain text from an uploaded research DOCUMENT (PDF / txt / md / docx) and ATTACH it to a client's research_documents (the high-trust corpus). Pass the file as a public/signed storage URL (fileUrl) OR base64 / a data: URL (base64 / dataUrl) plus a filename. With a clientId, the extracted text is appended to clients.research_documents so the NEXT structure-research (via analyze_offer, initial) or augment_research (regenerate) folds it in as GROUND TRUTH; without a clientId it just returns the text. SYNC. Returns { filename, text, char_count, format, truncated, attached, documentCount }. After attaching, call augment_research to regenerate angles from the doc WITHOUT re-scraping. PDF/txt/md are the guaranteed path; docx is best-effort (export to PDF if a docx fails). Cost: 5 credits per document.

Cost: 5 cr · Minimum tier: Starter

Required: filename

Optional: clientId, fileUrl, base64, dataUrl, source

create_low_ticket_offer ​

Build OR formalize a low-ticket offer onto a client. TWO modes: (1) COLD — for a client who does NOT yet have research, give a niche / business idea (and optionally a high-ticket back-end to reverse-engineer a front-end for); it decides the beachhead audience, reads the market (go/no-go), and builds a single $7-$97 low-ticket offer (name, price, big promise, format archetype, what's included, a day-one win, a 1-bump + 1-upsell stack). (2) FROM-RESEARCH (doc 59, cheaper, no LLM guess) — pass fromResearch:true + clientId to FORMALIZE the latest research_to_product spec for that client (or pass an inline productSpec). Either way, pass clientId to SAVE the offer onto the client (offer_name + prompt_context + marketing_data), then run analyze_offer -> generate. SYNC. Cost: 55 credits.

Cost: 55 cr · Minimum tier: Starter

Optional: idea, backEndOffer, audience, clientId, fromResearch, productSpec

structure_research ​

Synthesize the client's raw research corpus into the 28 named, addressable research sections (the structured research artifact) via a flagship model. Run this after audience research / scrape so downstream angle + creative generation can slice the research per format. ASYNC — returns { queued: true, jobId } in about a second, then poll check_generation_status({ jobId, jobType: 'structure-research' }) every ~2s. On completion the poll returns outputs: { artifactId, status, sectionCount } and the research_artifacts row with id = jobId is the delivered artifact. Cost: 690 credits. Tier: Pro.

Cost: 690 cr · Minimum tier: Pro

Required: clientId

decide_message ​

Decide the ONE message for the client's offer (the 8-field message decision: awareness stage, sophistication stage, saturation read, big idea, dominant emotion, positioning, primary angle, proof strategy) plus a set of tagged angles, in the order Saturation -> Sophistication -> Awareness. Run after structure_research. ASYNC — returns { queued: true, jobId } in about a second, then poll check_generation_status({ jobId, jobType: 'decide-message' }) every ~2s. On completion the poll returns outputs: { decisionId, decision, angles, model } and the message_decisions row with id = jobId is the delivered decision. Cost: 80 credits. Tier: Pro.

Cost: 80 cr · Minimum tier: Pro

Required: clientId

Optional: angleCount

generate_mechanism ​

Build or sharpen the client's UNIQUE MECHANISM and emit it as a clean schema (mechanism_name, the_how, the_proof, the_one_line, the_visual_metaphor, believability_check). Runs the 6-step operator (diagnose -> create -> name -> make-believable -> simplify -> dramatize) off the structured research + the decided message. the_visual_metaphor then feeds every IMAGE prompt (a model handed a Subject+Scene+Metaphor paints an ad, not a text card) and the_one_line/the_how/the_proof feed copy + video, so strategy is resolved before craft. Run after decide_message. Cost: 75 credits.

Cost: 75 cr · Minimum tier: Starter

Required: clientId

research_to_product ​

The PRODUCT IDEATION OPERATOR (doc 59): derive a validated low-ticket front-end product spec ($7-$97) FROM the client's buyer research. Runs AFTER the research chain (it reads the research_artifact + message_decision + mechanism + the scraped high-ticket price), so the product is DERIVED from evidence, not guessed. Emits one spec (product_format, named_mechanism, core_promise, price_band, primary_angle) plus the richer fields the offer-creators consume (big_promise, beachhead_audience, whats_included, day_one_win, order_bump, upsell, back_end_bridge, unmet_problem_targeted, competitive_gap_exploited, proof_to_lead_with) and a confidence tier (EVIDENCE-GROUNDED | DRAFT-ASSUMED | BLOCKED). Re-runnable to regenerate the product cheaply. Run after analyze_offer / structure_research. Cost: 75 credits. SYNC.

Cost: 75 cr · Minimum tier: Starter

Required: clientId

construct_offer ​

The OFFER OPERATOR (doc 116): construct the full low-ticket OFFER from the client's PRODUCT spec + research. Runs AFTER research_to_product (it reads the latest lt_product_specs row + the research artifact + message_decision + mechanism + the scraped/competitor price points), so the offer is constructed from evidence, not guessed. Emits the offer as a SPEC (name, one-breath promise, who-it-is-not-for, price + two value floors >=3x/5-10x, named mechanism demonstrate-then-name, bonuses-that-remove-resistance, the one objection, guarantee tied to the first win, four proof pillars, ~25 angles) PLUS the FULL STACK DESIGN (order bump -> upsell ladder strongest-first -> downsell -> condensation -> continuity-test -> catalog-backward-from-ceiling) as DESIGN/ideas, NOT built pages. Gated on the 30 offer-marks; a load-bearing miss sets status BLOCKED with a repair path (rerun_suggestions). Re-runnable to regenerate the offer cheaply. ASYNC — returns { queued: true, jobId } in about a second, then poll check_generation_status({ jobId, jobType: 'construct-offer' }) every ~2s. On completion the poll returns outputs: { offerSpecId, offerStatus, offer, marksScorecard, angleCount } and the lt_offer_specs row with id = jobId is the delivered offer spec (confidence tier EVIDENCE-GROUNDED | DRAFT-ASSUMED | BLOCKED on its status). Cost: 75 credits.

Cost: 75 cr · Minimum tier: Starter

Required: clientId

Optional: productSpecId

grade_offer ​

The PATH-A GRADER (doc 116 Phase 4): grade the client's EXISTING (scraped) low-ticket offer against the 31 product-marks + 30 offer-marks, then return the UPGRADED offer. Research-first by design: it requires a research artifact (run analyze-offer / the research chain first), because a great grade traces the offer against the buyer evidence, not the page alone. It (1) builds the current offer from the scraped marketing_data + the latest product spec, (2) scores it deterministically against both mark sets + surfaces the weakest proof pillar (the lowest pillar caps conversion), and (3) runs the OFFER OPERATOR in IMPROVE mode to emit the upgraded offer (same lt_offer_specs shape) + a diff of exactly what changed and why (by mark). Returns { grade (the two scorecards + weakest_pillar), currentOffer, upgrade { offer, status, offerSpecId, diff } }. The improve pass is called internally (no double-bill). Cost: 75 credits. SYNC.

Cost: 75 cr · Minimum tier: Starter

Required: clientId

Optional: improve

construct_stack ​

The STACK OPERATOR (doc 120): construct the full low-ticket value STACK that wraps the OFFER. Runs AFTER construct_offer (it reads the latest lt_offer_specs row + the latest lt_product_specs + the economics inputs: clients.financial_frame back-end price + the competitor ad-library price stickers as the cold-WTP proxy), so the stack is built from evidence, not guessed. Emits the FULL stack as a SPEC: backend_type, 3 order bumps (accelerant-first), 3 upsells (the next-problem loop, sorted strongest-first with prices stepping down), 3 downsells (each the matching upsell with the obstacle removed), condensation, the conscious continuity decision, the backward-from-the-ceiling catalog, and the COMPUTED AOV (the money number is code-owned via computeAOV, never hallucinated). DESIGN + AOV, NOT built pages (page-building is downstream / funnel-factory). Gated on the 30 stack-marks; a load-bearing miss sets status BLOCKED with a repair path. Returns a confidence tier + a marks scorecard. Cost: 75 credits. SYNC.

Cost: 75 cr · Minimum tier: Starter

Required: clientId

Optional: offerSpecId

grade_stack ​

The PATH-A STACK GRADER (doc 120): grade the client's EXISTING low-ticket STACK against the 30 stack-marks, then return the UPGRADED stack. Research-first by design (requires a research artifact + an offer spec). It (1) builds the current stack from the offer operator's offer.stack sketch + any scraped orderBumps/upsells, (2) scores it deterministically against the 30 stack-marks AND runs computeAOV (showing the REAL AOV + the bottleneck slot, the highest-leverage diagnostic), and (3) runs the STACK OPERATOR in improve mode to emit the upgraded stack (same lt_stack_specs shape) + a diff of exactly what changed and why. The improve pass is called internally (no double-bill). Cost: 80 credits. SYNC.

Cost: 80 cr · Minimum tier: Starter

Required: clientId

Optional: improve

generate_video_series ​

Turn ONE winning UGC video into a SERIES: produce N distinct topic concepts that all use the SAME format but each open a different door into the offer (a different pain, desire, objection, sub-audience, or use-case). Each topic returns { topic, hook, angle, why_it_works }, ready to hand straight to generate_video_script. The content-multiplier move ('give me 20 more in this format'). Grounded in the client's offer + audience. A stable clientRequestId lets callers recover the exact result after a timeout with action='status-by-request'. Cost: 55 credits.

Cost: 55 cr · Minimum tier: Starter

Required: clientId

Optional: action, operationId, count, format, notes, clientRequestId

verify_research ​

Adversarially verify the client's structured research against its source corpus: returns a per-section confidence + flagged claims (not-in-corpus / marketing-speak / invented-number) + an overall evidence-backed score, and stores it on the artifact. Run after structure_research to know how trustworthy the research is. Cost: 55 credits. Tier: Pro.

Cost: 55 cr · Minimum tier: Pro

Required: clientId

extract_brand_kit ​

Pull the client's visual brand identity (palette, fonts, visual style, logo) from their website via Firecrawl branding evidence plus a rendered vision pass. An initial extraction creates a named kit; re-extracting an existing kit creates a proposed revision that must be applied. Pass saveAsNew for a landing page or sub-brand so the current kit is never overwritten. Cost: 20 credits. Tier: Pro.

Cost: 20 cr · Minimum tier: Pro

Required: clientId

Optional: url, kitId, saveAsNew, name, kind, setDefault

list_brand_kits ​

List the named Brand Kits saved for one client, including the default selection, current accepted versions, and pending extracted revisions. FREE.

Cost: Free · Minimum tier: Starter

Required: clientId

set_default_brand_kit ​

Choose which saved Brand Kit all new visual generations use for a client. The exact accepted kit version is recorded in asset provenance. FREE.

Cost: Free · Minimum tier: Starter

Required: clientId, brandKitId

deconstruct_ad ​

Reverse-engineer a winning ad (image and/or copy) into a reusable playbook: hook + hook type, primary angle, format, awareness stage, emotional driver, visual + copy technique, why it works, a what-to-steal list, and a scroll-stopper score. Provide imageUrl and/or copy. Pass saveAsTemplate: true to ALSO save the deconstructed structure as a reusable ad-image prompt template in the org's custom prompt library (it then appears as a pickable template in the image factory). Cost: 25 credits. Tier: Pro.

Cost: 25 cr · Minimum tier: Pro

Optional: imageUrl, copy, headline, saveAsTemplate, templateName

generate_spy_brief ​

Synthesize the client's saved competitor winners into a strategic landscape brief: dominant angles, burned mechanisms, the market sophistication read, the whitespace gap nobody is using, and a concrete what-to-steal list. Reads the client's top saved competitor ads (longest-running and most-replicated) and runs one cheap pass over them. Save competitor ads first via a spy search. Always pass clientId (find it via list_clients). Cost: 10 credits.

Cost: 10 cr · Minimum tier: Starter

Required: clientId

Optional: includeCatalogue

update_client ​

Update an existing client's fields. The most important use is setting the GUIDELINES: the client's hard creative rules that MUST appear on every generated ad (e.g. 'always show the price', 'every ad must use the brand green', 'never mention competitors'). Guidelines flow into every generator's prompt as MANDATORY CLIENT RULES, both in the app and via this MCP. Can also update businessName, offerName, promptContext, sourceUrl. FREE.

Cost: Free · Minimum tier: Starter

Required: clientId

Optional: guidelines, businessName, offerName, promptContext, sourceUrl

generate_product_ads ​

Generate product ad images from an uploaded product photo: a vision pass analyzes the product, then each concept is rendered as an ad WITH the real product restaged (studio product still). Nano Banana Pro / Nano Banana 2 render through KIE with the product as a reference; gpt-image-2 uses OpenAI edits explicitly. Returns a taskId (async; poll check_generation_status). From MCP chat, call prepare_image_ads with surface='product_ads' first when you need help choosing the saved angle/model/size and checking whether the client has research ready. Cost: from 140 credits per image.

Cost: — · Minimum tier: Starter

Required: clientId, imageData, promptContext

Optional: businessName, adCount, imageSize, selectedAngle, selectedAngleId, expectedAngleText, guidelines, additionalNotes, model, styleMode

generate_product_stack ​

Generate digital-product mockup images (eBook, course, bundle, etc.) for the offer, on-brand. Cost: from 110 credits per image. Tier: Pro.

Cost: — · Minimum tier: Pro

Required: clientId, promptContext

Optional: businessName, offerName, selectedTypes, model, additionalNotes, clientRequestId

generate_product_matrix ​

Generate a winner-conditioned, judge-gated PRODUCT-AD MATRIX from ONE product photo: a diverse grid of scene x angle x format x persona cells, each rendered then scored /10 with a verdict before it ships. Three modes: 'explore' (default, diverse fresh cells), 'iterate_winner' (conditions the grid on the client's known winners — Brand Brain / Meta winner / scored saved ads; falls back to explore with a note if none exist), 'clone_competitor' (structure-transfer from a competitor ad image). Opt-in brand logo is auto-applied when the client has use_logo_on_ads on. ASYNC, returns taskId; poll check_generation_status (the ad_generation_tasks row carries each cell's image, score, verdict, and matrix axes). Priced per cell. Run after the client has an offer/research and a product image. Cost: from 110 credits per cell, reserved as unit x gridSize.

Cost: — · Minimum tier: Starter

Required: clientId

Optional: productImages, productImageUrl, offerContext, mode, gridSize, aspectRatio, model, businessName, additionalNotes, competitorAdUrl, competitorAdCopy, styleKeys, selectedAngleId, selectedAngle, expectedAngleText

generate_photo_edit ​

Create a NEW edited copy of an existing image via gpt-image-2's editing API: ai-cleanup (remove AI artifacts), custom-edit (free-form), or one of the messaging edit types from the photo-edit registry (headline-ad, hook-overlay, meme-caption, social-post-frame, testimonial-card, annotation-callout, ...). Use this for gallery Edit: preserve the original ad layout/composition/product/text unless the user's instruction changes it. GPT Image 2 failures fail/refund instead of silently switching to a different provider. From MCP chat, call prepare_image_ads with surface='photo_edit' first if you need the app-like missing-input checklist and a suggested custom-edit call. Returns the edited image URL. Cost: 110 credits per edit.

Cost: 110 cr · Minimum tier: Starter

Required: clientId, imageData, editType

Optional: promptContext, selectedAngle, selectedAngleId, expectedAngleText, model, clientRequestId

prepare_image_ads ​

READ-ONLY planning tool for using Spreng image generation from chat. Mirrors the app's selection step: checks whether the client has research/angles, picks or validates ONE messaging angle, ranks best-fit prompt plates/templates, blocks proof templates when no sourced proof exists, and returns the exact next MCP tool call. Use this before generate_ad_image/template ads unless you already know selectedAngle + selectedPrompts. Also returns guidance for product_ads, variations, photo_edit, and carousel flows. FREE (no credits) — this plans only; the generation call it suggests is what bills.

Cost: Free · Minimum tier: Starter

Required: clientId

Optional: surface, brief, angleId, angleText, count, imageSize, model, avatarPolicy, contextDepth, proofHeavy, useAvatar, avatarProfileId, personCasting, referenceImages, originalImageUrl, imageData, editInstruction, slideCount

creative_strategist_agent ​

⭐ THE CREATIVE STRATEGIST AGENT. Give it a brief (an offer URL or a few lines of context) and a clientId, and it runs the whole low-ticket creative loop for you: UNDERSTAND (scrape the offer + load the client's brand/offer/memory + reuse the client's STORED audience research) -> STRATEGISE (an LLM strategist baked with Fran's low-ticket direct-response doctrine decides the angles + the format-per-angle mix + a rationale) -> GENERATE (fans the chosen angles x formats out over the existing per-format generators). It thinks like a low-ticket creative strategist, not a generic ad bot: it classifies the situation (awareness, temperature, sophistication, dominant belief), applies the Distinctness Test + EPIC angle coverage + the belief-ratio, and deliberately diversifies so you do NOT get the same 5 ads. Returns IMMEDIATELY with { runId, status: 'understanding' } — the WHOLE loop (UNDERSTAND, STRATEGISE, GENERATE) runs in the BACKGROUND, so this response contains neither the strategy nor rendered cells. Poll check_generation_status with jobType 'agent-run' and jobId = runId (recommended interval 3s) for the live steps, the decided strategy, the final cells, and the terminal status (completed / completed_with_async / failed). The agent_runs row is the full audit trail. Billing: a run-level reasoning fee for the agent's planning (committed only after a valid strategy exists); each GENERATED asset bills its own per-cell credit. Run full audience research first; the Creative Agent will NOT silently start a multi-minute audience research run. It reuses the client's STORED audience_research if present and plans without an audience block if it is missing (it never kicks off Deep Research mid-run). When NOT to use: if the user wants ONE specific asset, call that single generate_* tool; if they only want the plan with no assets, call decide_creative_strategy instead. Cost: 120 credits for the strategist's planning run, then each GENERATED asset bills its own per-cell price on top.

Cost: 120 cr · Minimum tier: Starter

Required: clientId, brief

Optional: aspectRatio, depth, clientRequestId

generate_meme_hybrid ​

Generate a two-panel MEME ad whose panels show the CLIENT'S OWN FACE. Two machines render it: the image model stages each panel's art from the client's saved identity pack and renders NO text at all, then the layout engine stamps the copy over it as real DOM type, so every word is pixel perfect at any length. That split is the point, because garbled in-image text is the best-documented meme-ad craft failure and a deterministic canvas cannot draw a person. Formats (each carries a different ARGUMENT, so pick the one that fits the message): 'two-panel-reject-prefer-face' (Two panels of you: waving off the old way in one, sold on the new way in the other.); 'expectation-vs-reality-face' (The glossy version of your day next to what actually happens, both of them you.); 'switching-preference' (You walking away from the thing you used to settle for, straight toward the better one.). REQUIRES a saved avatar identity pack on the client with static-ad and paid-social consent confirmed; without one the call is refused before any credits are reserved. Every panel passes an originality check before anything is composited: a render that comes back as a recreation of a specific known image, or containing a real public figure, is refused outright with no retry and a full refund. Meme creative earns attention and cheap reach; the close still needs a proof-based creative behind it. The finished image is saved to the client's gallery. SYNCHRONOUS, returns the final imageUrl (~90s). Cost: 240 credits.

Cost: 240 cr · Minimum tier: Starter

Required: clientId, formatId, angle

Optional: angleId, aspectRatio, avatarProfileId

generate_texting_story ​

Generate an ANIMATED TEXTING STORY ad: a short MP4 of a text-message conversation that TYPES ITSELF OUT (3-dot typing indicators, bubbles dropping in one-by-one, the thread auto-scrolling, holding on the final bubble). It is the animated version of the native 'dm' screenshot and the highest impact-per-effort short-video format (≈78% completion vs a 52% baseline). Pass the offer/message as angle; gpt-4o writes a realistic, on-message 2-person DM thread (6-10 short natural texts ending on a soft CTA), then the doodle-engine renders it as a video with REAL legible text and emojis (not an image-model generation, so nothing garbles). The request is ASYNC. Create a stable clientRequestId before the first call and reuse it for any retry of the same intent. The tool returns a durable operation receipt immediately; when jobId is present, poll check_generation_status with jobType='ai-reels'. If only operationId is present, replay this tool with the same clientRequestId until the source job is linked. The finished video is saved to the client's library. Cost: 45 credits.

Cost: 45 cr · Minimum tier: Starter

Required: clientId, angle, clientRequestId

Optional: angleRef, aspectRatio, contactName

generate_portrait_talking_head ​

PHOTO -> TALKING HEAD: animate ONE uploaded photo of a REAL person into a lip-synced talking-head video of THAT person speaking your script (for VSLs + Reels/TikTok). Audio is generated with ElevenLabs (a stock house voice by default); the photo is animated + lip-synced via the KIE avatar models (OmniHuman primary, Kling Avatar fallback). This is DIFFERENT from generate_talking_head_ad, which INVENTS an AI presenter; this recreates a SPECIFIC real person from their actual photo. REQUIRES consent=true (the output is photorealistic synthetic media of a real person; you must have the right to use their likeness, they must be the advertiser/spokesperson, and the result must carry the platform AI-disclosure label on Meta/TikTok in 2026). Cloning the real person's OWN voice is a later v2 (needs that person's verified ElevenLabs voice); v1 uses a stock voice. ASYNC, returns a jobId; poll check_generation_status with jobType='ai-reels' (avatar render ~2-9 min). Pass a stable clientRequestId and reuse it exactly when retrying an ambiguous start, so a lost response cannot duplicate paid work. Cost: from 2900 credits.

Cost: — · Minimum tier: Starter

Required: clientId, imageUrl, script, consent, clientRequestId

Optional: voiceId, aspectRatio, model, resolution, messagingAngle

generate_podcast_ad ​

Generate a FAKE PODCAST CLIP ad: a short captioned MP4 of TWO AI 'hosts' on mics in a podcast studio, talking about the offer's problem / mechanism as if overheard (the rising, low-saturation 'eavesdrop on experts' trust format). Pass the offer/message as angle; gpt-4o writes a believable 2-host exchange (6-10 short alternating turns ending on a soft CTA), then the system generates two consistent host images (Nano Banana), voices each turn with two distinct ElevenLabs voices, lip-syncs each host to their line via the Kling avatar model (one speaker per clip), and concatenates the turns with word-timed sound-off captions into one video. The output is photorealistic synthetic AI presenters, so it must carry the platform AI-disclosure label on Meta/TikTok in 2026. ASYNC, returns a jobId; poll check_generation_status with jobType='ai-reels' (~3-8 min). The finished video is saved to the client's library. Cost: from 2600 credits.

Cost: — · Minimum tier: Starter

Required: clientId, angle, clientRequestId

Optional: aspectRatio, voiceIdA, voiceIdB, captionStyle, speakerColors, reactionCut, visualStyle, messagingAngle

generate_before_after ​

Generate a BEFORE/AFTER TRANSFORMATION video ad: a short MP4 that holds on a problem-state image, wipes (or slides) to reveal the result-state image, then holds on the result, with 'BEFORE'/'AFTER' pill labels and an optional headline overlaid. Top-tier convert-power (~2.5x engagement, 15-25% lower CPA) because motion makes the transformation believable. Pass the offer/message as angle; the writing model creates the on-screen labels + headline. Supply your own beforeImageUrl + afterImageUrl (both public http URLs, ideally the same subject/framing so only the transformation changes) OR omit them and the writing model creates the two scene prompts before the image provider generates the pair. The doodle-engine renders the reveal with REAL legible labels + headline (not an image-model generation, so nothing garbles). The request is ASYNC. Create a stable clientRequestId before the first call and reuse it for any retry of the same intent. The tool returns a durable operation receipt immediately; when jobId is present, poll check_generation_status with jobType='ai-reels'. If only operationId is present, replay this tool with the same clientRequestId until the source job is linked. The finished video is saved to the client's library. Cost: 250 credits.

Cost: 250 cr · Minimum tier: Starter

Required: clientId, angle, clientRequestId

Optional: angleRef, expectedAngleText, scriptGuidance, visualGuidance, beforeImageUrl, afterImageUrl, transition, aspectRatio

generate_listicle_ad ​

Generate a LISTICLE / 'N reasons' TEXT-MOTION video ad: a short MP4 of a kinetic numbered list. A title/hook card shows ('3 reasons I switched...'), then each point animates in one-by-one (number badge + bold headline + optional sub-line), the stack auto-scrolls, and it holds on the final call-to-action item. A workhorse format because viewers agree to watch on the premise of a list, and motion lifts message retention (~95% vs ~10% for static text). Pass the offer/message as angle; gpt-4o writes the hook + 4-6 escalating points ending on a CTA. The doodle-engine renders it with REAL legible bold type (not an image-model generation, so nothing garbles). The request is ASYNC. Create a stable clientRequestId before the first call and reuse it for any retry of the same intent. The tool returns a durable operation receipt immediately; when jobId is present, poll check_generation_status with jobType='ai-reels'. If only operationId is present, replay this tool with the same clientRequestId until the source job is linked. The finished video is saved to the client's library. Cost: 75 credits.

Cost: 75 cr · Minimum tier: Starter

Required: clientId, angle, clientRequestId

Optional: angleRef, aspectRatio, accentName

frame_showcase ​

Wrap a completed client video in a Framed Showcase recipe board. The inner video is reused without being generated or billed again. Choose exactly one sourceVideoId from the client's completed video library or a scoped private://client-footage-originals/... upload locator. Use copyMode='auto' with an angle/recipe description, or copyMode='manual' with exact board copy. Third-party product, company, tool, and platform names are refused in every visible field. The operation is durable and deliver-or-refund. Create one stable clientRequestId and reuse it for retries of the same intent. Poll check_generation_status with jobType='framed-showcase'. Cost: from 75 credits; the reused inner video is never billed again.

Cost: — · Minimum tier: Starter

Required: clientId, clientRequestId, durationSeconds, copyMode

Optional: sourceVideoId, videoUrl, angle, scriptGuidance, headline, subheadline, steps, ctaText, theme, accent, aspectRatio

generate_kinetic_hook ​

Generate a KINETIC TYPOGRAPHY hook-text video ad: a short MP4 of a punchy scroll-stopping hook delivered as full-screen bold animated text (phrases revealing one-by-one with a spring/scale entrance, one accent-coloured emphasis word per phrase, over a clean dark gradient background, with an optional small CTA line at the end). Faceless, dirt-cheap, and the #1 way to manufacture HOOK VOLUME (the first 1.7-3s decides most of the watch-through). Pass the offer/message as angle; gpt-4o writes 3-6 punchy hook phrases + a short CTA, then the doodle-engine renders them as a video with REAL legible text (not an image-model generation, so nothing garbles). Ideal feedstock for hook-remixing and creative testing. The request is ASYNC. Create a stable clientRequestId before the first call and reuse it for any retry of the same intent. The tool returns a durable operation receipt immediately; when jobId is present, poll check_generation_status with jobType='ai-reels'. If only operationId is present, replay this tool with the same clientRequestId until the source job is linked. The finished video is saved to the client's library. Cost: 45 credits.

Cost: 45 cr · Minimum tier: Starter

Required: clientId, angle, clientRequestId

Optional: angleRef, aspectRatio, accentName

generate_remix_hook ​

Durable HOOK REMIX. Keep a winning ad's body (with its old hook removed), create up to six new first-1-3-second hooks, prepend each hook, and save the finished variants to the client's video library. This is ASYNC and browser-independent. For action='start', provide clientId, bodyClips, and either hooks or angle. Create clientRequestId before the first call and reuse it after any timeout; the same payload returns the same operation and cannot buy duplicate KIE work. The start receipt contains operationId and usually jobId. Poll with action='status' + jobId, or action='status-by-request' + clientId + clientRequestId while the parent receipt is being linked. Use action='cancel' + jobId to stop unstarted variants. Accepted provider work remains billed. hookMode='text' uses an inexpensive kinetic text card; hookMode='clip' creates at most two fresh KIE clips and safely reuses them across the batch. Cost: up to 1,100 credits per batch. That number is a CEILING priced on the dearest clip model; the real charge is planned from what the batch actually renders (one copy call plus a hook card and a stitch per variant), so a text-mode batch bills well under it.

Cost: — · Minimum tier: Starter

Optional: action, clientId, clientRequestId, jobId, bodyClips, hooks, angle, angleId, expectedAngleText, scriptGuidance, visualGuidance, voiceoverUrl, voiceoverStartMs, words, musicUrl, hookMode, aspectRatio, captionMode, captionStyle, accentName, characterRef, kieModel

multiply_winning_hooks ​

MULTIPLY A WINNING UGC VIDEO INTO N NEW ONES, the hook-multiplication loop. Take a WINNING long-form UGC video you generated (a ugc_video_tasks PROJECT, via taskId), auto-reconstruct its BODY (scenes 2..N + the locked voiceover, with the original hook scene dropped), generate N fresh hooks, render each, and stitch each onto the SAME body, producing N complete new launch- ready videos. The hook is the #1 driver of watch-through, so swapping just the hook over a proven body is the highest-ROI way to scale a winner. PASS taskId (the project, from a completed generate_ugc_storyboard run) so the body is rebuilt automatically, NO manual clip wrangling. (Fallback: pass bodyClips/voiceoverUrl/words directly for an external winner with no project.) Provide the NEW hooks via hooks (one variant per line) or an angle for gpt-4o to write them. n = how many to make (default 5, hard cap 30; batched automatically). hookMode 'text' (default) renders kinetic on-screen hook-text cards (cheap, fast); 'clip' generates fresh character- consistent video hook clips (heavier). Every size returns a durable parent receipt. Poll this same tool with action='status' and jobId=taskId; do not infer completion from the latest gallery rows. Billed ONCE here (it calls the remix engine internally, no double-charge). Cost: up to 8,000 credits for the whole batch. That number is a CEILING; the real charge is the sum of the per-batch remix prices, planned from what each batch actually renders.

Cost: — · Minimum tier: Starter

Required: clientId

Optional: action, jobId, clientRequestId, taskId, n, hooks, angle, hookMode, bodyClips, voiceoverUrl, words, aspectRatio

generate_text_vsl ​

Generate a premium TEXT-ONLY VSL ad: a short MP4 (≈30-60s) where a voiceover plays over a solid/gradient background and the spoken words appear as LARGE, DYNAMIC kinetic text synced to the voiceover word-by-word (a rolling 3-5 word window centred big, the currently-spoken word lit up in the accent colour, subtle ambient background motion). NO footage, faceless, dirt-cheap to produce. This is the VOICEOVER-LED format (the VO sells, the kinetic text IS the VO word-for-word), distinct from generate_kinetic_hook, which is a 5-9s silent punchy hook card. Pass the offer/message as angle and gpt-4o writes a tight 30-60s VSL script, OR pass your own script verbatim. ElevenLabs makes the voiceover with word timings, then the doodle-engine renders REAL legible kinetic text (not an image-model generation, so nothing garbles). The finished video is saved to the client's library. This is ASYNC: create a stable clientRequestId, reuse it after any lost response, then poll check_generation_status with jobType='text-vsl'. Cost: 160 credits.

Cost: 160 cr · Minimum tier: Starter

Required: clientId, clientRequestId

Optional: angle, script, bgTheme, accentName, aspectRatio, musicUrl, voiceId, narrationEngine, angleRef, expectedAngleText

generate_whiteboard_comparison ​

Generate a VOICED 'X vs Y' WHITEBOARD COMPARISON EXPLAINER: a short MP4 drawn in a hand-drawn whiteboard style. The question is written at the top and underlined, two labelled sides are boxed in, a divider comes down between them, then each comparison row lands on the beat of the narration that describes it (the criterion, both verdicts, and a tick against the winner), and a verdict card closes. Use it for the decision a buyer is actually weighing: what they do today versus the offer's approach. Pass the offer/message as angle; the model picks the two sides, writes 3 to 5 criteria and the voiceover, and the doodle-engine renders it with REAL legible type (not an image-model generation, so nothing garbles). There is no presenter character. The request is ASYNC. Create a stable clientRequestId before the first call and reuse it for any retry of the same intent. The tool returns a durable operation receipt immediately; when jobId is present, poll check_generation_status with jobType='whiteboard-comparison'. If only operationId is present, replay this tool with the same clientRequestId until the source job is linked. The finished video is saved to the client's library. Cost: 170 credits.

Cost: 170 cr · Minimum tier: Starter

Required: clientId, angle, clientRequestId

Optional: scriptGuidance, angleRef, aspectRatio, boardStyle, accent, narrationEngine, voiceId, expectedAngleText

generate_vox_explainer ​

Generate a VOX-STYLE ANIMATED EDITORIAL EXPLAINER: a 30/60/90-second MP4 where a measured voiceover carries the argument and the visuals are real animated editorial graphics — kinetic headlines locked word-by-word to the narration's own timings, hand-drawn circles and underlines, a document that pushes in while everything but one region dims and a phrase gets highlighted, odometer stat counters, charts that draw themselves, colour-block chapter breaks. Every scene that puts evidence on screen carries a SOURCE citation taken from the client's own research; the generator REFUSES to invent one, and a client with no research loaded gets a film built only from headlines, annotations and colour blocks rather than a film with fabricated sources. This is the EXPLAINER format (it teaches, and it earns attention by being interesting), distinct from generate_text_vsl (a direct-sell kinetic caption VSL) and generate_whiteboard_comparison (an us-vs-them breakdown). Pass the offer as angle, set autoSelectAngle to resolve a saved angle, OR pass your own script verbatim. On-screen text is REAL rendered type, never an image-model generation, so nothing garbles. This is ASYNC: create a stable clientRequestId, reuse it after any lost response, then poll check_generation_status with jobType='vox-explainer'. Cost: 390 credits.

Cost: 390 cr · Minimum tier: Starter

Required: clientId, clientRequestId

Optional: angle, autoSelectAngle, script, scriptGuidance, visualGuidance, title, targetSeconds, aspectRatio, musicUrl, voiceId, narrationEngine, angleRef, expectedAngleText

generate_autocut ​

ONE-CALL AUTOCUT: give a clientId + ONE long raw source video URL, get back a finished short captioned vertical clip cut straight out of that footage. Gemini watches the source, picks the best N self-contained moments (strong hooks / punchy lines / compelling beats), then the moments are trimmed out of the SAME source, concatenated, and word-timed sound-off captions are burned in, then saved to the client's gallery. Use this when the client HAS long footage (a webinar, a podcast, a long testimonial, a vlog) but no editor. This is the RAW-FOOTAGE-IN, SHORT-CLIP-OUT archetype. For voiceover over STOCK B-roll use generate_broll_ad; for talking-head UGC use generate_video_reel kling-3.0; if you already HAVE separate short clips to join, use assemble_ugc_ad. ASYNC and resumable: returns a jobId immediately. Poll check_generation_status with jobType='autocut', or call again with the same clientRequestId to recover the same job. Cost: 25 credits.

Cost: 25 cr · Minimum tier: Starter

Required: clientId, sourceVideoUrl, clientRequestId

Optional: targetCount, maxDurationSec, scriptGuidance, visualGuidance, aspectRatio, captionMode, captionStyle, keepSourceAudio, messagingAngle

generate_copy ​

Generate written marketing copy for an offer — one tool, five formats via format: 'ad_copy' (5 Facebook ad variations), 'email' (5–7 email launch/nurture sequence), 'vsl_script' (video sales letter), 'landing_page' (full hero→FAQ landing copy), or 'messaging_angles' (a ranked, copy-free pain/desire/objection portfolio to select before writing). Messaging-angle client runs can continue durably; final ad copy is a separate selected-angle action. 'ad_copy' is ASYNC and REQUIRES clientId: it returns { queued: true, jobId } in about a second, then poll check_generation_status({ jobId, jobType: 'copy-write' }) for the variations. 'landing_page' is ASYNC and REQUIRES clientId too: poll check_generation_status({ jobId, jobType: 'landing-copy' }) — on completed, the delivered page is the funnel_content row with id = jobId. 'vsl_script' is ASYNC and REQUIRES clientId too: it returns { queued: true, jobId }; poll check_generation_status({ jobId, jobType: 'vsl-script' }) — completed outputs carry the script. When NOT to use: for images use generate_ad_image; for video use the video tools; for a full multi-asset campaign use generate_complete_campaign. Pricing is returned by the server-owned model pricing surface. Note: 'email' and 'vsl_script' require the Pro tier (enforced at generation time). Cost: 'ad_copy' 40 credits, 'email' 70 credits, 'vsl_script' 50 credits, 'landing_page' 65 credits, 'messaging_angles' 270 credits.

Cost: Free · Minimum tier: Pro

Required: format, promptContext, businessName

Optional: offerName, clientId, angle, angleId, emailCount, audienceProfile, model, copyVoice

assemble_ugc_ad ​

Assemble a VOICEOVER-DRIVEN video ad (the B-roll / VSL pattern): stitch N background clips into ONE video with a single locked voiceover over the top + word-timed sound-off captions, exported 9:16 / 4:5 / 16:9. FEED IT NON-SPEAKING B-ROLL — scene / product / lifestyle / screen-recording footage where the VOICEOVER does the selling. Do NOT feed talking-head 'selfie' clips of a person speaking to camera: one shared voiceover over a moving mouth will not lip-match and looks broken. For a person speaking on camera (talking-head UGC), use generate_video_reel with model='kling-3.0' + shots[] instead — it returns ONE multi-cut clip with NATIVE lip-synced audio and needs no assembler. Workflow here: obtain B-roll clips (generate scene clips, or fetch stock), then call this with the clips in play order + the script. It makes ONE ElevenLabs voiceover (captions auto-timed) or accepts a ready voiceoverUrl, then stores the finished ad in the gallery. voiceId / ttsModel are configurable. DURABLE ASYNC — returns a stable jobId, operationId, and clientRequestId immediately. Poll check_generation_status with jobType='ugc-assembly' and that jobId until completed; do not submit the same assembly again while it is processing. Cost: 110 credits per assembled ad.

Cost: 110 cr · Minimum tier: Starter

Required: clientId, clips, clientRequestId

Optional: script, voiceoverUrl, voiceId, narrationEngine, aspectRatio, captionMode, accent, messagingAngle

generate_broll_ad ​

ONE-CALL B-roll VSL ad: give a clientId + a script, get back a finished voiceover-driven video ad. It auto-segments the script into scene beats, finds matching stock B-roll per beat, generates one ElevenLabs voiceover, burns word-timed sound-off captions, stitches it, and saves it to the gallery. This is the VOICEOVER-OVER-FOOTAGE archetype (the VO sells over non-speaking B-roll). For talking-head UGC (a person speaking on camera, lip-synced), use generate_video_reel with model='kling-3.0' + shots[] instead. If you already HAVE the clips, use assemble_ugc_ad directly. To use the CLIENT'S OWN uploaded footage as the B-roll, add it first with add_client_footage, then set source='client' (their footage only) or 'mixed' (their footage first, Pexels fallback). Returns a final videoUrl when it finishes in-request, or status='processing' with jobId/jobType='broll-ad' for the durable queue. Poll check_generation_status when queued. Cost: 220 credits.

Cost: 220 cr · Minimum tier: Starter

Required: clientId, script, clientRequestId

Optional: aspectRatio, captionMode, voiceId, ttsModel, messagingAngle, messagingAngleId, source, visualGuidance, footageSteer

generate_talking_head_ad ​

DURABLE talking-head UGC parent: give a clientId, stable clientRequestId, and script, then get a resumable job where ONE AI person speaks the script TO CAMERA with NATIVE lip-synced audio. It generates the AI actor first frame, checks saved-presenter identity when explicitly editing an environment, plans 2-4 spoken cuts, and starts one stable durable Reel child. The same clientRequestId recovers a lost response without another paid provider submission. This is the TALKING-HEAD archetype — the person's own voice, lip-synced. Do NOT use this for voiceover-over-B-roll ads (use generate_broll_ad for that). ASYNC — returns the durable parent jobId; poll check_generation_status with jobType='ai-reels'. Cost: 1,400 credits.

Cost: — · Minimum tier: Starter

Required: clientId, clientRequestId, script

Optional: actorPrompt, actorPromptMode, subtype, reuseActorId, aspectRatio, messagingAngle, messagingAngleId, messagingAngleExpectedText

generate_hybrid_ad ​

ONE-CALL HYBRID ad: a talking-head HOOK hard-cut into a B-roll BODY. Give a clientId + a short hookScript (what the on-camera person SAYS, ~3-6s) + a bodyScript (the VOICEOVER script for the B-roll body). It renders the hook as a lip-synced talking-head clip with the person's OWN native audio, renders the body as a voiceover-over-stock/client-footage clip with captions, then JOINS them at a HARD CUT. The two are NEVER overlaid (no single VO across the talking mouth): the hook keeps its native lip-sync, the body carries its VO + captions, joined back-to-back so mouths never mismatch. Use this when you want the attention of a real face up front and the depth of a VSL body. For a pure talking-head use generate_talking_head_ad; for a pure VO-over-broll use generate_broll_ad. ASYNC: returns a jobId; poll check_generation_status with jobType='ai-reels' (the talking-head render is multi-minute, so total time is typically ~3-6 min). Cost: no hybrid-level charge; the two children bill normally, so a run costs the talking-head hook at 1,400 credits plus the B-roll body at 220 credits.

Cost: — · Minimum tier: Starter

Required: clientId, clientRequestId, hookScript, bodyScript

Optional: hookSubtype, angle, messagingAngleId, actorPrompt, actorPromptMode, reuseActorId, source, aspectRatio, voiceId, ttsModel

add_client_footage ​

Add a client's OWN video clips to their B-roll footage library, so generate_broll_ad can use them (source='client' or 'mixed'). Pass PUBLIC clip URLs — Google Drive FILE share links, Dropbox links, or any public mp4 URL. The SERVER downloads each clip, measures it, stores it durably, and auto-describes it with AI (Gemini) so it can be matched to script beats. NEVER pass video files or base64 through here — only URLs (video bytes through the MCP would be huge + useless). Link-based clips are capped at 32MB; larger originals are uploaded from the app's Footage Library and arrive here as a storagePath. You may pass description/tags per clip to skip auto-tagging. Up to 6 clips per call. PRICED PER CLIP, so a batch costs unit x clips and continuing a batch in a second call costs no more than doing it in one. Read count and warnings on the response: a call that catalogues nothing FAILS with the per-URL reason and is not charged, and a clip already in the library is skipped without being charged for. If remaining comes back, the request budget was reached — call again with exactly those clips. Cost: 15 credits per clip, so a batch costs 15 credits x clips.

Cost: 15 cr · Minimum tier: Starter

Required: clientId, clientRequestId, rightsBasis, clips

Optional: store, people

list_client_footage ​

List the clips in a client's uploaded B-roll footage library (added via add_client_footage), with their AI descriptions, tags, and URLs. Use it to see what footage is available before making a client-footage VSL with generate_broll_ad(source='client' or 'mixed'). Returns metadata only — never video bytes. FREE (no credits).

Cost: Free · Minimum tier: Starter

Required: clientId

clip_client_footage ​

Extract usable B-roll sections out of ONE long video already in a client's footage library. A clip here is an in/out point on the original, NOT a new video file — so every extracted clip is immediately usable by generate_broll_ad / generate_broll_video (source='client' or 'mixed') with nothing else to do. Three actions: action='list' reads the clips on a video (free); action='save' writes the exact set of ranges you supply, replacing what was there (free); action='auto' has the AI re-watch the video and propose clips (costs 10 credits, one call). Ranges are 3-60s each, non-overlapping, up to 24 per video, and each needs a short concrete description — that sentence is what decides which script beats the clip can fill. Use list_client_footage first to find the footage id and its duration.

Cost: Free · Minimum tier: Starter

Required: clientId, footageId

Optional: action, clips, replace

list_client_actors ​

List the saved AI presenters (actors) for a client, the faces previously generated by generate_talking_head_ad. Use it to find an actor to REUSE so the next talking-head ad keeps the same presenter: pass the returned id as reuseActorId to generate_talking_head_ad. Returns id, image_url, and label only, never video bytes. FREE (no credits).

Cost: Free · Minimum tier: Starter

Required: clientId

caption_video ​

Burn word-timed captions onto a FINISHED video at a public URL. Transcribes the clip's own audio (no stored word timestamps needed, unlike add_video_captions) and preserves the native sound. Returns the captioned video URL directly (SYNC; no polling). If no speech is detected it returns the original URL uncaptioned. Cost: 20 credits.

Cost: 20 cr · Minimum tier: Starter

Required: videoUrl

Optional: aspectRatio, captionStyle, captionMode, captionPacing, clientId

remix_captions ​

Re-caption an EXISTING generated video with N new caption/hook sets (different text, style, pacing) WITHOUT regenerating the video — the fast way to spin hook variants off one clip. The source is a completed generated_videos row (videoId) for this client, or a public videoUrl. Each set with no text reuses the clip's own transcribed words; a set with text overrides them. ASYNC, returns jobIds (one new generated_videos row per set; watch them land via the gallery / check_generation_status). Priced per variant. Cost: 20 credits per caption variant.

Cost: 20 cr · Minimum tier: Starter

Required: clientId, captionSets

Optional: videoId, videoUrl, aspectRatio

generate_ugc_storyboard ​

The DURABLE LONG-FORM UGC orchestrator. action=start takes an edited multi-scene storyboard and AI-generates each scene (Kling multi-shot / Veo / Seedance) with a locked character + voice, then stitch them into ONE finished long-form UGC ad and store it. Optionally locks the hero + turnaround + voice from a Character Card (a client_actors id). A Gemini video-judge gates per-scene QC (degrades to accept-unscored if no key). Start requires a stable clientRequestId and returns a durable taskId. Use action=status, advance, cancel with taskId, or status-by-request with clientRequestId. Output is AI-generated: enable the platform AI-disclosure label on upload. Billed dynamically per output second. Cost: from 1,600 credits.

Cost: — · Minimum tier: Starter

Optional: action, clientRequestId, taskId, clientId, storyboard, method, characterId, aspectRatio, selectedAngle, selectedAngleId

CAROUSEL (copy-first): decide a whole carousel as COPY first, BEFORE any image is rendered. Plans a carousel_spec { hook_formula, flow_framework, one_offer, primary_cta, slides:[{position, role, headline, body, text_overlay, image_prompt}] } built on the carousel doctrine (the 3 hook jobs, the 7-point Magnetism Checklist, the Swipe Commitment Gradient, the Poem Test) with the one-ad / hook / poem gates enforced in code. This is the RIGHT first step for a carousel: get the words + per-slide image direction, review/tweak them, THEN render. ASYNC (doc 346 Tier 1.4): returns { queued: true, jobId, carouselId } in about a second, then poll check_generation_status({ jobId, jobType: 'carousel-copy' }) — on completion its outputs carry the delivered spec, which also lives at carousel_ads.spec (row id = jobId; status copy_ready when persist, else a transient copy_draft). Zero delivery refunds the credit in full. Cost: 1 credit.

Cost: 1 cr · Minimum tier: Starter

Required: clientId

Optional: slideCount, angle, angleId, offerContext, mode, carouselFormat, hookFormula, ctaLabel, ctaUrl, funnelStage, skipFormat, variationOf, variationAxis, pretest, persist

generate_video_script ​

VIDEO SCRIPT (the Stage-1 for any video ad): turn an offer + messaging angle + video type into a hook-first VO script PLUS an editable scene-by-scene plan (one chunk per generated clip). ASYNC: it returns { queued: true, jobId } in about a second, then poll check_generation_status({ jobId, jobType: 'video-script' }) — on completed the outputs carry { script: { hook, script, scenes:[{index, vo, visual_direction, broll_keywords[], on_screen_text, duration_seconds}], cta, format, angle_used }, grounding, note } (delivered from video_scripts, row id = jobId). A retry with the same clientRequestId replays a completed request's persisted script inline. This is the RIGHT first step for a UGC / talking-head / podcast / b-roll ad: get the script + scenes, edit them, THEN render. CLONE-A-WINNER: pass competitorVideoUrl (a competitor's video) and it tears that ad down and clones its proven beat structure into your script, or pass sourceTeardownId (an already-saved teardown). Cost: from 40 credits (the registry floor; a dearer text model or a thinner plan tier bills more).

Cost: — · Minimum tier: Starter

Required: clientId, clientRequestId

Optional: videoType, scriptType, angle, autoSelectAngle, angleId, angleRef, expectedAngleText, durationSeconds, model, sourceTeardownId, competitorVideoUrl, offerContext, scriptGuidance, visualGuidance

refresh_angles ​

Find NEW, relevant messaging angles for an offer that's ALREADY running, without discarding the research. Re-pulls FRESH signals (competitor Meta ads via scan-ad-library + fresh Trustpilot/YouTube VoC), then generates angles that are genuinely DIFFERENT from the ones already in the client's set (diffed + deduped), each anchored to the campaign idea and tagged with its source + date. Fresh angles are copy-free and unselected; finished copy is written only in explicit generateSelectedCopy mode. Appends them onto the client's angle set as status:'new' for review (never overwrites). Use when a campaign has been running a while and needs fresh creative angles. ASYNC (doc 346 Tier 1.3) — angle generation returns { queued: true, angleJobId, refreshBatchId } in about a second; poll check_generation_status({ jobId: angleJobId, jobType: 'angle-refresh' }) every ~3s, then re-read the client's messaging_angles (rows of this run carry refresh_batch_id = refreshBatchId). A duplicate call while the same generation is in flight returns { queued: true, duplicate: true } with the active job id and reserves nothing. generateSelectedCopy / retryCopy mode still returns { queued: true, copyJobId } (jobType 'copy-write'). Cost: 5 credits per refresh, because the fresh-signal re-pulls run internally and are not charged; generateSelectedCopy mode additionally bills 40 credits for each selected angle whose five-ad copy is written.

Cost: 5 cr · Minimum tier: Starter

Required: clientId

Optional: count, model, refreshSignals, forceSignals, guidedSeed, generateSelectedCopy, selectedAngleIds, writeAngleIds, retryCopy, retryAngleIds

synthetic_persona_pretest ​

PRE-TEST the client's saved messaging angles/headlines against a SIMULATED ICP persona panel BEFORE any ad spend. Builds N diverse personas from the offer + audience research, simulates each reacting to every angle (scroll-stop x resonance - objection-friction), and RANKS the angles 0-100 so you cut the weak ones before they cost money: a loud-but-generic angle scores low; a specific, underserved, high-emotion angle scores high. Pass clientId (uses the client's saved messaging_angles). Usually returns { personas, ranked } directly; when the panel needs longer than the request window the response is instead a 202-style envelope { queued: true, jobId } (doc 346 R8: the model keeps thinking provider-side and the run settles in the background) — poll by calling this tool again with { clientId, jobId }, which returns the finished ranking at no extra charge (or the queued envelope again while it runs). Cost: 15 credits per new run; jobId reads are free.

Cost: 15 cr · Minimum tier: Starter

Required: clientId

Optional: personaCount, jobId

refresh_competitor_brand ​

Add/track a COMPETITOR BRAND and pull its LIVE Meta ads (the brand-centric spy). Pass a brandId to refresh an existing brand, OR clientId + name + (fbPageUrl OR keywords) to create-and-refresh one. Pulls the brand's active Meta ads via apify/facebook-ads-scraper, DIFFS against the ads already saved for that brand, and inserts only the NEW ones onto saved_ads (tagged brand_id, source 'automated', is_viewed false). Stamps the brand's watchlist clock (cadence). When the brand has no Facebook Page on file, it also DISCOVERS one from sources where the competitor stated it themselves (their own website's social links, or an already-scraped ad record for that advertiser) — never guessed from the name. Returns { brandId, scanned, newAds, totalAds, pageDiscovery }. Use to build the competitor board + keep it fresh. Cost: 75 credits.

Cost: 75 cr · Minimum tier: Starter

Optional: brandId, clientId, name, fbPageUrl, keywords, websiteUrl, maxAds

generate_product_mockup ​

PRODUCT STUDIO: manufacture a product image for a DIGITAL / INFO / low-ticket product that has no physical product to photograph (a book, a course-on-a-laptop/tablet/phone, a box, a bundle, a workbook, an audiobook), then produce CONSISTENT multiple angles of that exact object. Saves them to clients.product_photos (which the image generators auto-consume), so the client can then make product ads showing a real product. Returns { masterUrl, angleUrls, mockupId }. SYNC. Use when a client has no product photo. Omitting mockupType is SAFE: the portrayal is inferred from the client's offer, and the response reports which one was inferred and why (mockupTypeInferred + note). Pass it explicitly whenever you know better — an explicit choice is never overridden. Cost: 110 credits.

Cost: 110 cr · Minimum tier: Starter

Required: clientId

Optional: mockupType, sourceRefUrl, angles, aspectRatio, visualGuidance, clientRequestId

teardown_winning_video ​

Tear a COMPETITOR video ad down into a structured, model-able breakdown. Pass a competitor video URL (from find_winning_ads / the spy board) or raw base64, and Gemini video-understanding returns { format, durationSeconds, hook, voTranscript (VERBATIM), onScreenText[], beats[], cta, whyItWorks[] }. Unlike analyze_ad_image / the style 'plate' tools, this KEEPS the exact words so you can model the hook + script. Pass savedAdId to persist the teardown onto that spied ad (saved_ads.deconstruction). SYNC. Gemini inline cap ~20MB, so use a short clip. Returns { teardown }. Cost: 10 credits.

Cost: 10 cr · Minimum tier: Starter

Optional: videoUrl, videoData, savedAdId, mimeType

voice_lock ​

Speech-to-speech voice-lock: take a HUMAN voice read (source audio that carries the emotion + timing) and re-render it in a TARGET AI voice, preserving the source performance. This is the #1 real-vs-AI realism lever (Arc Ads). It kills the 'AI voice sounds like AI' tell and locks a clip to one consistent voice. The source can be a human read OR an existing clip's native audio. Pass audioUrl (http) OR audioBase64 (raw base64 or a data: URL). targetVoiceId defaults to the locked house voice (Adam); pass a stock/owned ElevenLabs voice id to re-voice TO it. ASYNC and durable. Returns { jobId, operationId, clientRequestId, status }. Poll check_generation_status with jobType='voice-lock'; never repeat a lost start with a new clientRequestId. Cost: 120 credits.

Cost: 120 cr · Minimum tier: Starter

Required: clientId, clientRequestId

Optional: audioUrl, audioBase64, targetVoiceId, mimeType, durationSeconds

relip_video ​

Re-dub / lip-sync an EXISTING video: take a finished clip + a NEW audio track and re-sync the speaker's MOUTH to that audio (re-voice an ad, dub it to another language, swap the VO). No new pixels are generated — only the mouth is re-lipped to the new audio. Pairs with voice_lock (re-voice the audio first, then re-lip the clip to it). Powered by Volcengine V2V lip-sync. ASYNC: action:'start' returns { videoId, dbRecordId }; poll with action:'status' (and the same videoId + dbRecordId) until status==='completed', which returns { videoUrl }. videoUrl: the source clip (<=500MB, 360p-1080p). audioUrl: the new audio (<=10MB). mode 'lite' (single frontal speaker, default) or 'basic' (complex / multi-speaker scenes). Cost: from 130 credits.

Cost: — · Minimum tier: Starter

Required: action

Optional: clientId, videoUrl, audioUrl, mode, separateVocal, openScenedet, durationSeconds, videoId, dbRecordId

critique_creative ​

Quality-check generated marketing copy (ad copy, email, VSL script, landing copy, or angles) before it ships. Scores it out of 10 against a direct-response rubric (hook, retention, proof, CTA, native feel), flags AI tells (em dashes, invisible hype, triple negation, filler), and returns a verdict: 'ship' (score >= 7, clean), 'revise' (>= 7 with fixable issues), or 'reject' (score < 7, do not spend generation budget, rewrite). Shape: { score 0-10, verdict, rubric, ai_tells, strengths, fixes }. Use it as the QA step after a generate_* / generate_copy call: if verdict is 'revise'/'reject', regenerate with the fixes folded into promptContext, then re-check (cap 1-2 passes). When NOT to use: to PLAN a campaign use decide_creative_strategy; this judges copy that already exists. Cost: 10 credits (one reasoning call).

Cost: 10 cr · Minimum tier: Starter

Required: content

Optional: format, offerContext

score_ad ​

Score an AD IMAGE or VIDEO out of 10 before it ships (the Ad Score surface). Images run the visual judge rubric (hook/stopping power, clarity, product prominence, craft, native feel); videos run the video judge (hook in first 3s, pacing, clarity, native feel, CTA) plus retention-risk notes, first 90s analyzed. Returns { score 0-10, verdict ship|revise|reject (reject under 7 is code-enforced), breakdown, fixes[] } and persists the score (gallery chips pick it up on owned assets). Pass asset_id for a generated asset (ad_images.id or generated_videos.id) OR asset_url for external/uploaded media. This is a doctrine-rubric judge, not a spend-trained predictor. For COPY use critique_creative instead. Cost: 20 credits (image) / 80 credits (video, <20MB clip).

Cost: 20 cr · Minimum tier: Starter

Required: client_id, asset_type

Optional: asset_id, asset_url, context

duplicate_video_ad ​

DUPLICATE A COMPETITOR VIDEO AD: feed a competitor ad VIDEO; we (1) deconstruct it with Gemini video-understanding into its creative structure + transcript, (2) re-storyboard it with YOUR client's full offer/brand context, then (3) route the restage to Seedance, Kling, or Veo. Seedance uses the competitor clip as its reference video; Kling/Veo can use your product image as the first frame. The two Seedance input modes are deliberately not combined because its API treats first-frame I2V and multimodal reference-video generation as mutually exclusive. This is the Spy tool's video twin of the image 'Create Your Version'. Source the competitor video from a saved video ad (Find Winning Ads now captures video_url) or any public HTTPS video URL. The server checkpoints every phase, supports 100MB+ sources by streaming them through Gemini Files, and resumes after client disconnects. ASYNC, returns a jobId; poll check_generation_status with jobType='ai-reels'. Output is AI-generated: enable the platform AI-disclosure label (Meta/TikTok) on upload, and it swaps out the competitor's brand/logo/copy (it recreates the STRUCTURE, not their creative). Cost: 1,200 credits per duplicated video.

Cost: — · Minimum tier: Starter

Required: clientId, sourceVideoUrl, clientRequestId

Optional: productImageUrl, angle, newScript, brandNotes, aspectRatio

manage_brand_memory ​

Read and write the client's durable BRAND BRAIN: the learnings that make every future strategy and generation brand-aware. The creative strategist reads this on every run and writes distilled learnings after every run; use this tool to inspect it or to teach it. Memories are kinds like brand_fact, winning_pattern, rejection, guidance, run_summary or note, ordered pinned first, then by salience (weight), then recency. Actions: list (return the memories), add (teach a new learning), delete (remove one by id), pin (pin/unpin one by id so it always leads the brief). FREE (no credits). Always pass clientId (find it via list_clients). Use add to record a brand voice rule, a winning angle, or a direction the operator rejected so the strategist stops repeating it.

Cost: Free · Minimum tier: Starter

Required: action, clientId

Optional: content, kind, source, id, pinned

manage_meta_connection ​

Connect or check a client's Meta ad account via a bring-your-own System User token. The user pastes their OWN non-expiring Meta System User access token with ads_management for the client and picks an assigned ad account; it is stored securely per-client and can read performance and use the guarded PAUSED launch flow. FREE (no credits). Actions: validate (list the ad accounts the token can read, stores nothing), save (store the token + chosen ad account), status (is this client connected, which ad account), disconnect (remove the stored connection). The raw token is NEVER returned. Always pass clientId (find it via list_clients).

Cost: Free · Minimum tier: Starter

Required: action, clientId

Optional: accessToken, adAccountId, adAccountName

get_meta_insights ​

Read a connected client's recent Meta ad performance (spend, ROAS, CPA, CTR by ad), the data source for the Agent v3 learn loop. Uses the client's stored bring-your-own System User token (connect it first via manage_meta_connection). Returns rows sorted by spend with entity-level identity, hierarchy ids/names, spend, impressions, clicks, ctr, cpc, purchases, revenue, roas, and cpa. Identity fields match the requested aggregation level. FREE (no credits). Always pass clientId (find it via list_clients).

Cost: Free · Minimum tier: Starter

Required: clientId

Optional: datePreset, level, carouselCards, adId

meta_launch_preflight ​

Run the real Meta launch dry run for a client's paused campaign build. This creates ZERO Meta objects and spends ZERO budget. It validates the exact preset + selected ads against Meta, checks the connected account, and when ready returns the single-use preflight receipt required for the paused launch call. Requires the caller to have write access to the client. FREE (no credits).

Cost: Free · Minimum tier: Starter

Required: clientId, selectedAds

Optional: presetId, preference, flexSingleAd

meta_launch_campaign ​

Launch a Meta campaign through Spreng's paused launcher. Fresh launches always create the campaign, ad set, and ads PAUSED. This tool does NOT expose in-app activation. Use action=launch after a passing meta_launch_preflight receipt, action=resume for a parked launch, action=pause to stop a completed launch's delivery, or action=emergency_pause to pause every Spreng campaign for the client. Requires client write access. FREE (no credits) — Spreng charges nothing to launch; the ad spend itself is billed by Meta.

Cost: Free · Minimum tier: Starter

Required: clientId

Optional: action, launchId, presetId, preference, selectedAds, flexSingleAd, receiptId, receiptHash

meta_launch_status ​

Read the state of a client's Meta launch without mutating Meta. Use action=list for recent launches, action=get for the normal launch header + item ledger, action=bundle for the full support bundle, or action=rotation_check to confirm flexible-ad rotation attached on created ads. Requires client write access. FREE (no credits).

Cost: Free · Minimum tier: Starter

Required: clientId

Optional: action, launchId

upload_media_to_meta ​

Push a generated image or video straight to a connected client's Meta ad-account media library (no campaign, ad set, or ad is created). Use it to get an asset into the account so you can attach it to an ad in Ads Manager. Connect the account first via manage_meta_connection. Returns { imageHash, status: 'ready' } for an image, or { videoId, status: 'processing' } for a video — Meta finishes transcoding a video AFTER this returns and can still reject it, so confirm a video in Ads Manager before relying on it. Images are deduped by Meta on content, so re-sending the same image returns the same hash; videos are NOT deduped, and sending the same file twice leaves two library entries. If it fails with code 'meta_write_unknown' the upload may or may not have landed: check the media library before sending it again, never resend blind. FREE (no credits). Always pass clientId (find it via list_clients).

Cost: Free · Minimum tier: Starter

Required: clientId, mediaType, url

Optional: name

Push a FINISHED carousel's cards into the connected client's Meta ad-account media library and get back a READY carousel-ad payload: per-card image hashes + child_attachments (card headline <=45 / description <=18 / link from the spec's per-card ad copy) + the deck's primary_text and organic caption. Build the ad in Ads Manager (or via API object_story_spec.link_data.child_attachments) in one paste. With pageId + createCreative=true it ALSO creates the carousel AD CREATIVE itself (ready to attach to any ad set; a creative cannot spend money; card order locked, no auto-reordering). List the account's Pages first with action='pages'. Never creates a campaign/ad set/ad. Requires a connected Meta account (manage_meta_connection) and a completed carousel. FREE (no credits).

Cost: Free · Minimum tier: Starter

Required: clientId

Optional: carouselId, destinationUrl, action, pageId, createCreative

learn_from_meta_performance ​

Read a connected client's live Meta performance, pick the genuine winner (best ROAS above a meaningful spend floor), and record it in the client's Brand Brain so the AI strategist learns from what actually converted. On a leads / traffic account with no purchase events it falls back to the top CTR ad. Connect the account first via manage_meta_connection. Returns the learnings written plus the winning row(s). FREE (no credits). Always pass clientId (find it via list_clients).

Cost: Free · Minimum tier: Starter

Required: clientId

Optional: datePreset

manage_support_tickets ​

Create, list, reply to, and update Spreng support tickets. Users see their own tickets; admins see all tickets and can reply or set status. This backs the bottom-right in-app support chat and Admin -> Tickets. FREE.

Cost: Free · Minimum tier: Starter

Required: action

Optional: ticketId, status, subject, description, message, pageUrl, userEmail, clientOperationId, limit

manage_prompt_library ​

Manage Spreng prompt plates/custom prompts through the MCP. Actions: list_system, list_community, list_library, create_custom, add_community, set_sharing. For generation, prefer prepare_image_ads: it ranks best-fit prompt plates instead of dumping the full library. Use list_* only for browsing with search/filter terms. Custom prompts created here get the same format/angles/subject taxonomy used by Best Fit Ads. FREE. PUBLISHING IS PUBLIC: set_sharing true, and create_custom with shareWithCommunity, make the plate readable by every Spreng account. Your full prompt text becomes visible to every Spreng account. Check it for client names, prices, or offers before sharing. Confirm with the user before sharing a plate you did not write. add_community takes a COPY of the plate as it reads at that moment, so later edits by its author do not change what the importing account generates.

Cost: Free · Minimum tier: Starter

Required: action

Optional: promptType, promptId, name, description, promptText, category, shareWithCommunity, isShared, search, format, angle, subject, qualityTier, limit

admin_grant_credits ​

Admin-only: grant positive bonus credits to an active organization member. Uses the canonical add_credits RPC through the admin-grant-credits edge function, records a billing audit row, and refuses negative adjustments. FREE.

Cost: Free · Minimum tier: Starter

Required: userId, organizationId, amount

Optional: reason

Notes ​

  • All async tools return a { jobId, jobType }. Poll check_generation_status with that pair every 2-3s until status === "completed".
  • All paid tools charge credits on success. Failed calls (Anthropic error, rate limit, etc.) refund the reservation automatically.
  • Free tools (audit-only) don't deduct credits but still write to mcp_audit_logs.
  • Tier blocks fire at the MCP layer in <1s — the underlying edge function is never called when the tier is insufficient.
  • Daily credit cap kicks in at 1500 / 5000 / 15000 credits per 24h for Starter / Pro / Agency.

Spreng — built on the Model Context Protocol

© Spreng. All rights reserved.