WWevi Developers

MCP Tools Reference

Detailed schema specifications for every Wevi Model Context Protocol tool.

Wevi MCP Tools Reference

The @wevi/mcp package exposes 39 Model Context Protocol tools. The happy path is list templates → read schema → create one project with all scenes → trigger render → poll status. Every scene of a video lives in one project and is exported as one concatenated MP4.

  1. wevi_list_templates — pick published templates from one aspect ratio.
  2. wevi_get_template_schema — read each template's editable layer keys.
  3. wevi_create_project — one project with scenes: [...].
  4. wevi_trigger_render — render every scene and export one MP4.
  5. wevi_get_render_status — poll until phase is completed, then use videoUrl.

1. wevi_list_templates

List published templates. Only published templates can be used in projects; drafts and archived templates are never returned to API keys.

FieldTypeRequiredDescription
categorystringNoFilter by category (SaaS, CTA, Problem, Solution, Motion, …)
aspectRatio"16:9" | "16:12" | "9:16"No16:9 = 1920×1080 widescreen, 16:12 = 1920×1440 desktop-app frame, 9:16 = 1080×1920 vertical (the templates that have a vertical version)
searchstringNoKeyword matched against names, slugs and descriptions
limitnumberNo1–100 (default 100: the whole library, in story order)
pagenumberNoPage number

Each result carries aspectRatio (the template's own frame), aspectRatios (every ratio a video using it can be made in; 9:16 when it has a vertical version), storyboardRole (the beat it plays best: hook, problem, solution, proof, cta or transition), fitsBeats (every beat it can play), purpose, avoid, tone, voiceoverBudget (max words and characters for the scene length), requiresUiCapture, uiCaptureSlots, and for capture templates fitsUi and alsoSuitsUi (the kinds of interface they show best: match them against productUi from wevi_open_page). A paged result says incomplete. Pick all templates for one video from a single aspect ratio. Templates with requiresUiCapture: true show real product UI: capture a page into those scenes with wevi_capture_scene after creating the project. Capture slots you leave unfilled render empty (no stock or demo imagery), so capturing fewer components than uiCaptureSlots.max is safe.


2. wevi_get_template_schema

Returns the editable layers of a template: key, label, type (text, color, slider, toggle, dropdown, image, …), role (logo, external_logo, avatar, background, brand_name, ui_component), autoFill (what Wevi fills the layer with when you leave it unset), description, default value, validation (min/max) and dropdown options. Hidden and protected layers are omitted. brandLogoLayers lists the keys that need a brand logo. The result also carries previewVideoUrl and thumbnailUrl, and the tool attaches the thumbnail as an image so you can judge the look of the animation before committing to it.

FieldTypeRequiredDescription
templateIdstringYesTemplate ID or slug

3. wevi_create_project

Create one project containing all scenes of the video. The aspect ratio is derived from the templates; mixing ratios is rejected. Pass aspectRatio: "9:16" for a vertical video: every template must have a vertical version.

FieldTypeRequiredDescription
titlestringNoProject title
aspectRatio"16:9" | "16:12" | "9:16"NoLeave out to use the templates' own frame; 9:16 renders each scene from its template's vertical version
scenesScene[]Yes1–12 ordered scenes
brandIduuidNoExisting brand to attach (skip when passing brand)
brandBrandNoBrand for logo and color layers; required (websiteUrl or logoUrl) when any template has a logo slot

Brand:

FieldTypeRequiredDescription
websiteUrlstringNoProduct website or domain, e.g. stripe.com. Wevi fetches the logo, colors and fonts and reuses the brand on later projects
logoUrlurlNoPublic logo image (png, svg, jpg, webp) when there is no website, or to override its logo
namestringNoBrand or product name
primaryColor, secondaryColorstringNoBrand colors (hex)

Scene:

FieldTypeRequiredDescription
templateIdstringYesPublished template ID or slug
parametersobjectNoLayer key → value ({"TXTTYPINGVAR": "Hello"})
voiceoverTextstringNoNarration mixed in at export
titlestringNoScene title

Returns projectId, aspectRatio, sandbox, the resolved brand and the created scenes, each with autoFilled (layer keys Wevi filled from the brand: logo, app logos, avatars, backgrounds, colors) and templateCopy (layers still showing the template's own words). It also returns scenesNeedingCapture (capture each with wevi_capture_scene before rendering), planReview (fix every entry in planReview.issues before rendering), and credits, with a creditWarning when the balance cannot pay for the whole video. If a template has a logo slot and the brand has no logo, the call is refused with missingBrandAssets; ask the user for the product website and retry.


3c. wevi_update_scene

Change one scene after creation, typically to fix a failed render without rebuilding. The next wevi_trigger_render re-renders only scenes whose inputs changed, and charges for those scenes.

FieldTypeRequiredDescription
projectIdstringYesProject ID
sceneIdstringYesScene ID
parametersobjectNoLayer key → value, merged over current values; null clears
voiceoverTextstringNoNew narration within the scene's budget
titlestringNoNew scene title

3d. Revising a project

Change a project without rebuilding it. The next wevi_trigger_render re-renders only scenes whose inputs changed.

ToolFieldsNotes
wevi_add_sceneprojectId, templateId, position?, title?, voiceoverText?, parameters?Same aspect ratio as the project; unset layers auto-fill; capture templates then need wevi_capture_scene
wevi_remove_sceneprojectId, sceneIdRemaining scenes close the gap
wevi_reorder_scenesprojectId, sceneIds[]Every scene id exactly once, in the new order
wevi_swap_templateprojectId, sceneId, templateId, parameters?Matching parameters carry over; dropped keys are listed

Text layers you leave unset on create, add or swap are filled from the scene title, else the start of the narration, else the project title. Layers that still show the template's own words are listed per scene as templateCopy; set them with wevi_update_scene when the copy matters. A required text layer with nothing to draw from is refused with missingText.


4. wevi_get_project

Inspect a project's scenes, layer values and lifecycle status. The response also lists pendingCaptures (scenes that still need wevi_capture_scene) and a nextStep.

FieldTypeRequiredDescription
projectIdstringYesProject ID

5. wevi_trigger_render

Render every scene, then export them as one video with music and voiceover. Waits up to waitSeconds; if the video is not ready it returns the current phase for polling.

FieldTypeRequiredDescription
projectIdstringYesProject ID
quality"720p" | "1080p" | "4K"YesWhen paidAccess is true (any credit pack bought, or a paid plan), ask the user once before the first render: 1080p for web and social, 4K (slower to export, and it costs more) for large screens. Otherwise pass 720p: a free account asking for 1080p or 4K gets 403 EXPORT_QUALITY_LOCKED. Sandbox keys are capped at 720p without an error
includeMusicbooleanNoDefault true. Projects with no track yet get one from the Wevi library automatically; the response's music says which
musicTrackIdstringNoLibrary track id to use instead of the automatic pick. Needs paid access (403 FEATURE_NOT_AVAILABLE otherwise)
voiceIdstringNoNarrator from wevi_list_voices instead of the default. Needs paid access (403 FEATURE_NOT_AVAILABLE otherwise)
includeVoiceoverbooleanNoDefault true. Narration is generated from each scene's voiceoverText
soundEffects"off" | "subtle" | "full"NoSound design planned by Wevi (see Sound effects). subtle is quieter and sparser and suits most product videos; full is a launch-trailer feel; off suits a calm or personal piece. Saved on the project; omitted, the project's setting stands (off unless set). No extra credits
soundStyle"clean" | "cinematic" | "playful" | "tech"NoCharacter of the cuts' and accents' sounds, matched to the music: clean (the default), cinematic for a dramatic launch, playful for a light consumer product, tech for developer tools and AI products. Saved on the project
waitSecondsnumberNo0–55 (default 45)

Calling wevi_trigger_render again after a failed export, with the same options, starts that same export again: it is not charged twice, and scenes already rendered are not rendered again.


5b. wevi_get_scene_previews

Per-scene render results: state, a preview URL for each rendered scene (the scene alone, without music), and the error for failed ones. Scenes that failed before reaching the renderer say "Credit refunded". Takes projectId.

5c. wevi_list_music and wevi_list_voices

Library tracks with mood and genre tags (wevi_list_music takes an optional query), and narrator voices with preview clips. Pass musicTrackId or voiceId to wevi_trigger_render; without them Wevi picks a track for the brand's tone and the default narrator.

5d. Sound effects

Wevi plans a video's sound effects itself, for its scenes and its narration, by the rules a sound designer keeps:

  • A sound only on a moment the eye follows: a cut, a title or logo landing, a click, a message popping in, an element flying in. Nothing where nothing happens.
  • The right sound for what happens. Every template's moments were timed on its preview, and each was given the library sound that matches it: Payment done when a payment is confirmed, Message pop when a chat message appears, Enter key when a command is submitted, Stamp when a badge is stamped on.
  • Not every cut. A cut gets a whoosh when the story moves on (problem to solution, into proof) or the picture moves fast across it. A cut where the same thought carries on, where the voice runs across it, or between two calm frames stays bare. Cuts between short scenes never whoosh one after another.
  • Accents on the full treatment: a hit on the opening title, a soft hit on the logo, with quiet just before it.
  • The voice comes first. Sounds landing on a spoken word sit lower; a light touch leaves the movements out. Everything ducks under the voice in the mix.
  • One palette. The same action sounds the same through the video, and the cuts take turns between two whooshes of the style.
  • Never busy. At most three sounds in any second (two on a light touch), a few to a scene, levels matched for how loud each sound actually is.

Templates that carry their own sound keep it and get none of Wevi's. The plan stands on its own; the tools below read it and change single sounds when there is a reason. Each returns the sound design as it now plays, with advice: what a sound designer would fix (empty when the sound is right).

ToolWhat it doesFields
wevi_get_sound_designEvery sound with its key, scene, moment (atSeconds into the scene), what happens there, the library sound, its levelDb against the plan; the sounds taken out; the scenes; the library; the advice. Read-onlyprojectId
wevi_set_sound_effectsSets the level, style and volumeprojectId, level, style, volume (0–100)
wevi_change_soundAnother library sound, a level against the plan (levelDb: 0 as planned, -3 a clear step quieter), a moment (nudgeSeconds, within 2 seconds), and for typing, ticks or scrolling how long it runs (lengthSeconds; the sound repeats to fill it). Values are set, not steppedprojectId, key, sound, levelDb, nudgeSeconds, lengthSeconds
wevi_add_soundA library sound at a moment of a sceneprojectId, sceneId, atSeconds, sound, levelDb, lengthSeconds
wevi_remove_soundsTakes sounds out; they stay under removedprojectId, keys
wevi_restore_soundsPuts sounds back, or with all undoes every change to single soundsprojectId, keys, all

6. wevi_get_render_status

Poll render + export progress. Returns phase (idle, rendering, exporting, completed, render_failed, failed) and videoUrl once completed, with music and voice. Polling is also what starts the export once every scene has rendered. review, when present, is Wevi's check of the finished video: share videoUrl once review.status is done with no issues; otherwise fix the scenes it names (each issue has a suggestedFix) with wevi_update_scene and render again. beforeSharing says what to check with the user first.

FieldTypeRequiredDescription
projectIdstringPreferredProject started with wevi_trigger_render
exportIdstringAltLook up a single export record
waitSecondsnumberNo0–55

While exporting, export.stall says when the export is not moving: paused when it has waited a few minutes with nothing putting videos together yet (it starts as soon as exports resume), quiet when it stopped making progress again after being started again. An export that stops making progress is started again once on its own (export.restarted: true), as the same export and without charging again. nextStep says what to do in each case.


7. wevi_generate_storyboard

Plan a storyboard from a brief against the published templates. The plan already follows the create rules, so its createPayload can go straight to wevi_create_project: every scene uses a published template from one aspect ratio, each scene's narration sits inside that template's voiceover budget as a complete sentence, on-screen copy is written for the template's text layers, and scenes that show real product UI are flagged so you know what to capture. Charged as a storyboard draft on live keys (see costs in wevi_get_credits) and takes 20–60 seconds (progress is reported while it runs).

FieldTypeRequiredDescription
promptstringYesGoal, product, audience and tone
brandNamestringNoBrand or product name
brandUrlstringNoProduct website or domain; becomes createPayload.brand.websiteUrl so create can fetch the logo and colors
brandVoicestringNoTone of voice
brandIdstringNoA saved brand from wevi_list_brands (wins over brandName / brandUrl)
maxScenesnumberNoExact scene count, 3–12. Omit to let the brief and runtime decide (3–6 scenes)
targetDurationSecondsnumberNo10–180; scene count and pacing follow it, so longer videos get more scenes
aspectRatio"16:9" | "16:12" | "9:16"NoAspect ratio for every scene (default 16:9); 9:16 plans a vertical video from the templates with a vertical version
captureUibooleanNotrue when the user has a live product page to capture (prefers UI templates); false avoids capture templates
sessionIdstringNoA session open on the product (from wevi_open_page): templates are matched to the interface its pages show (productUi)

Returns credits, planReview, productUi, draft (title, narrativeAngle, aspectRatio, totalDurationSeconds and scenes), createPayload, notes and nextStep. Each scene lists order, title, purpose, visualDirection, templateId, templateName, storyboardRole, durationSeconds, voiceover, voiceoverBudget (seconds, maxChars, maxWords), onScreenText, parameters (layer key → copy), textSource (ai, onScreenText or none), textLayerKeys (the template's text layers; empty when it has none), requiresUiCapture, captureSlots and captureHint. Show the plan to the user, adjust wording if asked (stay within voiceoverBudget.maxChars), then send createPayload to wevi_create_project; when the draft had no website, ask for it and add it as createPayload.brand.websiteUrl first. Sandbox keys are limited to 4 scenes per project, and drafts made with them respect that.


8. Browsing before you capture

Use these when the right shot is not the top of a public page: a tab, a modal, a dashboard behind a login the user walks you through, or a section further down.

Limits: 12 session opens per minute, 60 browse or outline calls per minute, 3 open agent sessions at a time, and a daily browser-time allowance (120 minutes on live keys, 40 on sandbox keys); past a limit the tool returns a 429 that says when it resets. A session stays on the site it was opened for, plus any site you open on purpose with a goto step: a step that lands on another site is undone and reported as refused.

wevi_open_page

Open a live browser session and get the page outline: headings, links, sections with their vertical positions, scroll state and a small screenshot of the view it opens on. Wevi also looks down the rest of the page for you: an overview image shows its further views, numbered by their place down the page (1 is the top), and productUi counts the interface found further down, labelled as such.

FieldTypeRequiredDescription
urlstringYesPage to open
projectId, sceneIdstringNoSets the viewport to that scene's template

On a marketing site, the result may also carry appEntry and appHint: where the product itself is (often behind a sign-in), since the product's own screens usually make better scenes than its marketing pages.

Browsing in the session

One tool per step, each taking sessionId (from wevi_open_page) and an optional screenshot (default true), and each returning the resulting outline and screenshot. Steps that look like payments, purchases, deletions or account changes are refused; at most 150 steps per session; only http(s) pages, on the site the session was opened for or reached with wevi_go_to.

ToolFieldsWhat it does
wevi_go_tourlOpens another page of the site, or one of the app's routes; like wevi_open_page, returns an overview of the rest of that page
wevi_clickselector or text, opensMenu?Clicks an element; opensMenu: true clicks, of the controls whose text matches, one that opens a menu or list first
wevi_typeselector, text, submit?, clear?Types into a field; never a password
wevi_hoverselectorShows what appears on hover
wevi_scrollselector or y or ratioScrolls to an element, a pixel position, or a share of the page (0–1)
wevi_waitms or selectorWaits for a time (at most 10 s) or for an element to appear
wevi_press_keykeyPresses a key, e.g. Escape or Enter
wevi_go_backGoes back one page; returns an overview like wevi_go_to
wevi_wait_for_logintimeoutSeconds? (15–300, default 180)Call right after sending the user loginUrl: waits until they press I am signed in or the sign-in screen goes away, then returns signedIn and the app's routes

wevi_close_page

Close the session. Agent sessions also close after 10 minutes idle, when the project is published, or after 55 minutes. Browser time is metered: the first minutes of each session are free, then each started block is charged, shown as "Browser session" in the usage panel; sandbox keys are free. Each capture is charged as a page capture. The current free minutes, block length and costs are in wevi_get_credits.


wevi_capture_from_image

Use a still image at a public URL as the captured page. Works for templates whose whole background is the page (uiCaptureSlots.fullPageBackground); templates that animate individual elements need the live page. Free.

FieldTypeRequiredDescription
projectId, sceneIdstringYesScene to fill
imageUrlurlYespng, jpg or webp, up to 15 MB; fitted to the frame
pagenumberNoFor templates that show several pages (uiCaptureSlots.pages): which page this image fills, from 1. Left out, the next page not yet captured

8a. wevi_capture_scene

Capture a live web page into a scene whose template needs a UI capture. Loads the URL, detects UI components the same way the Wevi app does, auto-selects the best ones, and makes the scene render-ready. Charged as a page capture on live keys.

On a page nobody scrolled, Wevi looks down the whole page, view by view, and captures the view whose components suit the scene best; the result's lookedDown says where: the stops looked at (scanned), the views measured (views), the view taken (top, moved), each view's rank (scores) and, with annotate, the quick look stop by stop (looked). A view you scrolled to in the session is kept as it is, and selectors are brought into view wherever they sit on the page.

FieldTypeRequiredDescription
projectIdstringYesProject ID
sceneIdstringYesScene ID, from scenesNeedingCapture in the create response
urlstringNo*Product page to capture. *Required unless sessionId is given
focusstring[]NoUp to 6 keywords matched against component labels and text, and against the words of each part of the page when Wevi looks down it, e.g. ["pricing table"]
selectorsstring[]NoUp to 6 exact CSS selectors to use, in order; overrides auto-selection
autoSelectbooleanNofalse captures and lists candidates without choosing (with a numbered screenshot), for an agent-driven pick
sessionIdstringNoOpen session from wevi_open_page; captures its current view (url optional)
frame"auto" | "current" | "full"Noauto (default) narrows the viewport and scrolls so the chosen components fill about 60% of the frame; current keeps the view as browsed; full is the top of the page
targetFillnumberNo0.3–0.95, default 0.6
keepSessionbooleanNoKeep the session open (returns sessionId) to capture more scenes from the same site
annotatebooleanNoAlso return a screenshot with numbered candidate boxes
pagenumberNoFor templates that show several pages (uiCaptureSlots.pages): which page of the template this capture fills, from 1. Left out, the next page not yet captured. The result's pages says which are captured and which are missing; a page left empty repeats the captured ones

A page whose title or headings say it does not exist ("404", "This page could not be found") is captured if you ask, but the result carries notFound: true and a warning: check the address and capture the page you meant before rendering. Every page outline also carries notFound.

Returns the chosen components, the candidates list ranked best-first (label, type, size, selector, number, suggested), the template's slots (min/max picks or full-page background, plus the template's selection rubric: guide, smartGuide with the author's do and don't notes, prefer, avoid, size, targetFill, and, for templates whose frames have been measured, frameShape (min–max width over height a frame shows whole) and frameSize (width, height and crops: how large a frame shows a component, in the page's own pixels)), captureNotes explaining how captures work, elapsedMs, and renderReady. Candidates are ranked by your focus hints first, then by fit: page content over navigation, headers and footers; cards, buttons and inputs over loose text; readable sizes over slivers and whole sections. A capture opens the page in a real browser, closes cookie and consent notices (choosing "reject" or "necessary only" when offered, otherwise "accept" or the close control) after every navigation, hides sticky bars and chat widgets, recaptures the background with the chosen components hidden, and usually takes 40 to 70 seconds; the tool reports progress while it runs. The page is measured first without a screenshot, framed once if the picks need it, then captured once over a single browser connection, so auto framing no longer costs a second capture. timingsMs in the result shows where the time went (openSession, steps, probe, frame, capture, finalize). frame in the result says which viewport and scroll position were used. If the choice is wrong, re-pick without reloading:

8b. wevi_select_capture

Choose different components from an existing capture. Takes projectId, sceneId, captureId, and selectedComponentIds (for text templates the first id must be the text element); optional keepSession, and cursorPoints for cursor templates (up to 12 { x, y } stops in the capture's pixels, in order; omitted, the stops are spread over the selected components). Free.

8c. wevi_capture_web_ui

Standalone screenshot of a URL, returned as an image URL for templates with a plain image slot (logo, avatar, background).

FieldTypeRequiredDescription
urlstringYesPublic or app URL (e.g. https://linear.app)
selectorstringNoCSS selector to crop one element
viewportstringNodesktop (1280×720, default) or mobile (390×844)

Returns screenshotUrl and title. Charged as a page capture on live keys.


0. wevi_get_capabilities

Returns what Wevi can and cannot make, the questions an agent should ask before building, the supported aspect ratios, sandbox limits, and credit costs. Takes no parameters and makes no API call. Agents should call it first in a new conversation, and whenever a request sounds outside Wevi's scope (for example "make a dance video").

The same statement is sent to the client as the server's instructions on connect, so assistants that honour MCP instructions already have it.

9a. wevi_list_brands

Brands saved on the account with website, logo and colors. Pass one as brandId to wevi_create_project to reuse it.

9. wevi_get_credits

Show the credit balance for the current key's account, which the studio spends from too. It returns plan (allowance, used, remaining, period), rolloverCredits, purchasedCredits, heldCredits, totalAvailable, paidAccess, costs (credits per action right now), team, and key (this key's own monthly cap). Takes no parameters. Call it before a large batch, or when a tool fails with 402. Credits are bought by the user in the Wevi app, under Profile → Billing.


💳 Credits

Live keys and connectors spend the same credits as the studio and the studio agent. There is no separate API bill.

ActionCharged
Scene render: a new scene, or one changed since its last renderPer scene
ExportPer export, more at 1080p and more again at 4K
Storyboard draft (wevi_generate_storyboard)Per draft
Page capture (wevi_capture_scene, wevi_capture_web_ui)Per capture
Live browser session (wevi_open_page)Free for the first minutes, then per started block
Creating a project, re-picking components (wevi_select_capture), sound changesFree

Prices and plan allowances change, so this page does not list them: costs in wevi_get_credits is what each action costs now. Free accounts get a one-time credit grant, for videos up to the free length at 720p with a watermark. Credit packs are the main way to buy more: they never expire and unlock 1080p and 4K, no watermark, longer videos, and your own music and voice; paid plans add a monthly allowance. Users buy credits under Profile → Billing in the Wevi app.

When an action cannot go ahead, the tool says why, with the numbers:

  • 402 INSUFFICIENT_CREDITS: the credits needed, available and set aside for a video in progress.
  • 402 KEY_MONTHLY_CAP: this key reached its own monthly cap (set on the API Keys & MCP page).
  • 403 FREE_VIDEO_TOO_LONG: a free account's video runs past the free length; remove a scene.
  • 403 EXPORT_QUALITY_LOCKED and 403 FEATURE_NOT_AVAILABLE: the quality, music or voice asked for needs paid access.
  • 429: a sandbox allowance or the daily browser minutes ran out, with the reset time.

See API Keys & Credits.


🧪 Sandbox keys

With a wevi_test_ key every tool works the same, but renders are watermarked, exports are capped at 720p, and nothing counts against your credits. Status responses include sandbox: true.

Each test key has a hard daily allowance: 20 scene renders, 5 exports, and 4 scenes per project, resetting at 00:00 UTC. Past the cap, wevi_trigger_render returns a 429 message with the reset time.


🔐 Capturing Private & Authenticated Dashboards

Templates often need real product UI that sits behind a login. Wevi keeps the human in the loop:

  1. Never share passwords with an assistant. Agents are told not to ask for them, and Wevi never stores typed text in its logs.
  2. Log in once, in your own browser. Every page the agent looks at reports whether it is a sign-in screen (authWall) and carries loginUrl, a link of the form https://app.wevi.ai/browse/live?sessionId=…. When a page needs a login, the agent sends you that link; it opens the same cloud browser the agent is using. You sign in there (SSO and 2FA included) and press I am signed in. A sign-in window the site opens, such as Sign in with Google, Apple or Microsoft, shows on that page as a tab of its own, and the page comes back once the window closes. The agent waits with wevi_wait_for_login, then reads the app's routes (its own navigation: dashboard, reports, settings…) and captures the view the scene needs. A sign-in screen never costs a credit: wevi_capture_scene returns loginRequired: true instead of capturing the form.
  3. Logins persist per account. The browser profile is kept for your Wevi account, so later captures from the same site are already signed in. The same profile is used by the capture browser inside the Wevi app.
  4. Reset any time. The Browser logins control on the API Keys & MCP page clears the stored browser profile.
  5. Sandbox keys never reuse logins. wevi_test_ keys always browse in a fresh, anonymous profile.
  6. Guardrails. Agent steps cannot click anything that looks like a payment, purchase, deletion or account change, are limited to 12 per call and 150 per session, cannot open non-web URLs, and every step is recorded on the project (what was clicked or typed into, never the text).

Direct image fallback still works: drop a screenshot into the chat and ask the agent to use it as a plain image layer.


⚖️ Capture Methods Compared: Wevi Browser Engine vs. Chat Drag-and-Drop

Feature / CapabilityWevi Browser Capture Engine (wevi_capture_scene)Direct Screenshot Drag-and-Drop in Chat
Headline & Copy Extraction✅ Extracts clean text directly from the DOM✅ Claude OCRs visible text from the image
Brand Color Extraction✅ Reads computed CSS hex / RGB codes✅ Visual color sampling by the LLM
Static Full-Screen Mockups✅ Supported✅ Ideal use case for flat images
Text Punching / Erasure✅ Erases baked text so animated typing layers don't overlap❌ Text is baked into pixels
Precision Motion Coordinates✅ DOM bounding boxes feed camera & cursor motion⚠️ Estimation only
True Font Stacks & TTF Files✅ Extracts computed font-family, weight, and Google Font files❌ Not possible
Dynamic Border-Radius Masks✅ Applies computed CSS border-radius with alpha edges⚠️ Depends on the source crop