VODOO AI · AGENT SURFACE

Your agent can runthe whole studio.

Not a render endpoint with a docs page bolted on. 22 tools that walk the entire loop — find the ad that is working, pull its hook apart, write against it, render every variant, ship the one that won. Point Claude, Cursor or your own orchestrator at one URL and it has the studio.

What it can do, end to end

  1. 01

    Find

    Search the ad libraries the workspace can reach, then read an ad's hook, angle and beat structure.

    search_adsextract_hook
  2. 02

    Write

    Hang a brief off the product facts and turn it into a hook, body and CTA.

    create_briefgenerate_script
  3. 03

    Word it

    Hand it a picture, frames from a video or a rough idea and get the prompt back: the main one, a negative, other ways to say it, and a shot list for video.

    write_prompt
  4. 04

    Page it

    One person, a list of first lines and a handful of rooms, laid out as posts in the order to publish them — which room, which hand, and which of them are renders rather than the same room with different words over it.

    plan_account
  5. 05

    Render

    Make N variants of one prompt or one recipe row — pass `kind` for an image, a voice read, music, a 3D model or copy; it defaults to video — then poll until the files land.

    render_variantsget_job_status
  6. 06

    Cut

    Join the clips end to end in the order they play, with transitions, a voice track and a music bed under it, delivered in up to four aspect ratios at once.

    assemble_cut
  7. 07

    Ship

    Pull the finished files through short-lived signed links and record the publication so its performance can be attributed later.

    list_assetspublish_draft

The boring part, which is the part that matters at 3am

An agent cannot see a spinner or a balance, so nothing here spends on its first call. Ask a tool to do something expensive and it comes back with the preflight instead: what it would make, what it would cost, and which key’s cap that lands against. It runs when you ask again with confirm: true — a yes with a number in front of it, which is the closest thing to informed consent a program can give.

Credits are held when the job is submitted and settled against what the provider actually billed. Anything unused comes back. Nothing expires. Of the 22 tools, 6 can move credits at all and each one carries a spends annotation in tools/list, so a client can show the gate before the model ever calls it.

→ render_variants { prompt, kind: "video", count: 4 }

← preflight — nothing was queued
  4 variants · <credits> to run
  against key "ci" · <remaining under its cap>

→ render_variants { …, confirm: true }

← queued · 4 job ids · credits held
  poll get_job_status

The shape of the exchange. The figures come back filled in from your own workspace’s rates.

Every tool, and what it costs you

What a key is allowed to do

The list is deliberately short. A permission model nobody understands gets granted in full every time, which is the same as not having one. The key an agency pastes into a client’s CI can render and nothing else — not read the asset library, not register a webhook that forwards every future render somewhere.

generations:read
Check whether a render finished, and read its error if it did not.
generations:write
Start renders. This is the only scope that can spend credits.
assets:read
Download finished files through short-lived signed links.
usage:read
Read this key's own spend and rate-limit budget.
webhooks:write
Register and remove webhook endpoints for this workspace.
recipes:read
List saved recipes and the variables they take.
research:read
Search competitor ads and read saved ad analyses.
text:refine
Run written copy through the editing pass. Reads nothing, writes nothing, costs nothing.
orders:write
Report a sale back: this asset, this amount, this order id. Spends nothing, reads nothing, and cannot see anything else in the workspace.

Connecting it

Streamable HTTP, spoken as plain JSON-RPC over POST. Create a key under Settings → API keys, tick the scopes it needs, and point any MCP client at the endpoint.

{
  "mcpServers": {
    "vodoo": {
      "url": "https://vodoo.ai/mcp",
      "headers": {
        "Authorization": "Bearer vd_live_…"
      }
    }
  }
}

Limits, stated plainly

  • No SSE stream. A stream exists so a server can push, and this one pushes nothing: every tool that starts work returns a job id and you poll get_job_status. A render outlives any connection an agent will hold open, and advertising a stream we never write to would be a promise clients wait on.
  • Twelve variants a call, one kind a call. render_variants makes a video, an image, a voice read, a piece of music, a 3D model or written copy — whichever kind you pass. It will not take a hundred of them in one breath.
  • A refusal is not a protocol error. No credits, wrong id, gate declined — those come back as a successful result with isError and a readable reason, so the model can act on it instead of retrying blind.
  • Schemas cannot drift. The tools are defined in Zod and their JSON Schemas are derived, so the schema an agent reads in tools/list is the one the handler validates against.

Hand this page to the thing that will use it

Increasingly the first reader of a page like this is a model comparing tools on someone’s behalf. The button copies this page as markdown — endpoint, every tool, every scope, the confirm rule and the limits — built from the same array the list above renders, so it cannot describe a tool set we do not serve.

Run the studio from your agent · VODOO AI