Your agents, wired into the creative engine.

The Cleom MCP server will expose the production pipeline — ad campaigns, prompt-to-video generation and your Game Profile — as tools any MCP client can call. Claude, Claude Code, Cursor, Windsurf, your own agents: one config block and they're producing on-brand creative. It's coming soon; today, Cleom runs through the app, starting with Ad Campaigns.

Overview

What the Cleom MCP server is

MCP — the Model Context Protocol — is the open standard that lets AI assistants and agents talk to external systems through typed tools. The Cleom MCP server is our implementation of that standard: a thin, secure bridge between any MCP-compatible client and your Cleom workspace.

Connect it once and your assistant gains real production capability. It can read your Game Profile — your game's brief, brand and references, which keep output consistent — and it can trigger real production jobs against your prepaid credit balance, with the cost always shown before production starts. The heavy lifting still happens on Cleom's pipeline; MCP is just the steering wheel.

That unlocks workflows that used to need a human in the dashboard: a producer asks Claude to spin up 20 ad variants from inside Slack, an engineer wires a CI hook that briefs a fresh ad batch for every major update, a community manager's agent pulls the latest delivered variants straight into a scheduling tool. Same pipeline, same brand guardrails — new front doors.

It will ship in two forms: a local server you run with a single npx command, and a hosted remote endpoint at mcp.cleomai.com for clients that prefer streamable HTTP.

Tools

What the server exposes

generate_campaign(game_id, brief, formats, variants)  → job
create_video(game_id, prompt, ratio, duration)        → job
estimate_cost(tool, params)                           → credits
get_job(job_id)                                       → status
query_library(game_id, filter, sort, limit)           → assets
get_game_profile(game_id)                             → profile

generate_campaign

Trigger a full ad campaign run — one brief in, 10 to 200 ad variants out across formats and hooks, each delivered separately. Takes a brief, a format list (9:16, 1:1, 16:9) and a variant count; returns a job ID with a credit estimate. Production starts once the request clears review.

create_video

Prompt-to-video through Create. Describe the shot, set a ratio and a target duration, and automatic Model Routing picks the right model for the job — no model shopping, no settings maze.

estimate_cost

Get the credit cost of a campaign or video before you commit — the same cost preview the app shows before anything goes to production. Agents call it first to keep spend inside budget.

get_job

Check any job — in review, in production, delivered or failed — plus credits used. Failed jobs refund their credits automatically, and the refund shows up right here.

query_library

Search everything your workspace has produced — filter by type, campaign, status (in review, in production, delivered) or date. The tool agents use to fetch finished assets, variant by variant.

get_game_profile

Read your game's context: the brief, brand, tone and references your workspace holds. Agents call this early so every downstream request is grounded in your IP.

Setup

One config block

Add the server to claude_desktop_config.json, a project-level .mcp.json for Claude Code, or your IDE's MCP settings. The local server runs over stdio via npx — no install step:

// .mcp.json — local server (stdio)
{
  "mcpServers": {
    "cleom": {
      "command": "npx",
      "args": ["-y", "@cleom/mcp"],
      "env": {
        "CLEOM_API_KEY": "clm_live_••••••••••••••••",
        "CLEOM_GAME": "shatterbound"
      }
    }
  }
}

// or point at the hosted remote server (streamable HTTP)
{
  "mcpServers": {
    "cleom": {
      "type": "http",
      "url": "https://mcp.cleomai.com",
      "headers": { "Authorization": "Bearer clm_live_••••••••••••••••" }
    }
  }
}

CLEOM_GAME is optional — set it to scope the session to one Game Profile, or omit it and pass game_id per call. Works with Claude, Claude Code, Cursor, Windsurf, Zed and any client that speaks MCP.

In practice

An agent session, end to end

you    We're soft-launching Shatterbound in SEA in two weeks.
       Cut 20 vertical ad variants with a boss-fight hook.

agent  › get_game_profile("shatterbound")
       Profile loaded — brief, brand and references ready.

agent  › estimate_cost("generate_campaign",
         { formats: ["9:16"], variants: 20 })
       Estimated 1,400 credits. Proceed?

you    Go.

agent  › generate_campaign({ game_id: "shatterbound",
         brief: "SEA soft-launch, boss-fight hook, fast cuts",
         formats: ["9:16"], variants: 20 })
       Submitted as job_8f3k2 — production starts after review.

you    Ping me when the first five variants land.

agent  Will do. I'll watch query_library for status
       "delivered" on job_8f3k2 and report back with links.

This is the workflow the MCP server is being built for — the same jobs Ad Campaigns runs in the app today, with the same request review, upfront cost and variant-by-variant delivery. The agent just removes the clicking.

Auth

API keys, scoped and revocable

Workspace-bound keys

Keys are issued per workspace from the dashboard — clm_live_ for production, clm_test_ for dry runs that validate calls without spending credits.

Three scopes

read (profile + library), generate (render jobs), admin (profile edits — off by default). Give a CI bot generate, give an analytics agent read-only.

Rotate without downtime

Issue a replacement key, roll your config, revoke the old one. Every tool call is logged against the key that made it, so audits are one query away.

Keys stay server-side

The MCP server reads the key from environment or header — it's never exposed to the model, never echoed in tool results, never written to the conversation.

Limits

Rate limits

Generous defaults, tuned so an agent loop can't accidentally drain a credit balance. Production tools draw from the same prepaid credits as the app — $10 for 1K up to $699 for 100K, and they never expire — and limits scale up with the larger packs.

Limit	Default
Tool calls per minute	60
Concurrent production jobs (campaigns / videos)	4
Queued jobs per workspace	25
get_job status checks per minute	120
query_library results per page	100

Hitting a limit returns a structured error with a retry_after hint, so well-behaved agents back off automatically. Need more concurrency for launch week? Write to hello@cleomai.com.

Roadmap

Where it's headed

PHASE 01 — FIRST RELEASE

The six core tools

Local (npx) and hosted remote server, API-key auth with scopes, job queuing with upfront cost estimates, and library queries — everything on this page.

PHASE 02 — FAST FOLLOW

Resources, push and write access

Game Profiles exposed as MCP resources so clients can load your brief, brand and references as ambient context; webhook-style push for job events instead of polling; and write tools — update_game_profile and push_performance to feed ad results back into generation as Insights comes online.

PHASE 03 — LATER

Deeper control

Canvas node-graph control over MCP, tools for Steam Page, Store Kit and Asset Lab as those surfaces launch, OAuth for hosted multi-user clients, per-member tool permissions, and a workspace-wide audit log surface for studio compliance teams.

Be first in line.

The MCP server is coming soon. Leave your email and we'll send the config block the day it's live — until then, Ad Campaigns is live in the app: one brief in, 10–200 ad variants out.

Building something specific? Tell us at hello@cleomai.com.