Skip to main content
Glama

Server Details

AI video editor for agents and humans: timeline, captions, color, audio and generation as MCP tools.

Ownership verified
Status
Healthy
Uptime
100.0% over the last 24 hours
Last Tested
Transport
Streamable HTTP · MCP 2025-11-25
URL
Repository
AnrosPrac/arsaze-mcp
GitHub Stars
0
ChatGPT
–
Claude
–

TDQS

A3.5/5.0

Scored across 25 tools

Disambiguation3/5

Several boundaries are fuzzy: arsaze_call can run any catalogue tool, blurring with directly exposed tools and with run_timeline_batch; screen_login and screen_hand_over both cover user authentication; and show_generated_asset vs show_generated_results are close. Descriptions help, but an agent must reason about dispatcher vs direct tool and login vs hand-over.

Naming Consistency3/5

All names are snake_case with helpful domain prefixes (arsaze_, screen_, ws_), but the verb order is inconsistent: arsaze_* and run_* are verb-first, while screen_*, ws_*, and media_look are noun-first. Within each group it is predictable, but the overall set mixes two conventions.

Tool Count3/5

25 tools sits at the heavy end of the 16-25 borderline range. The breadth (video timeline, screen recording, workspace files, generation) justifies many tools, but the dynamic catalogue (arsaze_tools/arsaze_call) could have reduced the up-front surface.

Completeness4/5

The exposed tools cover full lifecycle for screen recording and workspace file operations, plus discovery, credits, and result display. Timeline editing and project export are delegated to the catalogue via arsaze_call, which is a workable escape hatch but not a direct surface; minor gaps remain.

Available Tools

25 tools
arsaze_callA
Destructive
Inspect

Run any Arsaze tool from the catalogue by name.

tool: exact name from arsaze_tools (e.g. "split_clip_at"). args: that tool's arguments as an object.
confirm: true only for a destructive/credit-spending tool the user explicitly asked for.
response_detail: "summary" (default — ids + what changed) | "ids" (every id, no timeline) | "compact" (the
whole timeline, nulls stripped) | "full". Over-budget results
come back as a workspace file path to ws_grep/ws_read instead of inline.
fields: dotted paths to return only those parts, e.g. ["clips[].id"]. cursor: next page of a long list.
A bad call returns the tool's exact signature — fix the args and call again.

Inputs: tool (required), args, cursor, fields, +2 more.

arsaze_estimate_generation_costA
Read-only
Inspect

Show the user exactly what a generation will cost in credits BEFORE running it, as an interactive card with a Generate button.

Call this FIRST, instead of asking "shall I generate? it will use some
credits" — you do not know the rate, it is set per plan and per model by
an admin and changes without any code change, so any number you state
from memory will eventually be wrong. This reads the user's real plan
and real balance and prices the run the same way the generation itself
will.

Nothing is charged and nothing is reserved by calling this. It is a
quote. Generation only starts if the user then asks for it.

kind: "video", "image" or "voice".
provider: the model id you intend to use — get real ones from
  video_gen.list_providers / image_gen.list_providers, never from
  memory. Omit to quote the plan's standard rate for that kind.
duration_seconds: the duration you intend to request. Only affects
  duration-priced models; harmless to pass otherwise.
quantity: how many separate generations (e.g. number_of_images).

Inputs: kind (required), provider, quantity, duration_seconds.

arsaze_show_creditsA
Read-only
Inspect

Show the user's real credit balance, plan and usage limits as a card.

Use this when they ask what they have left, or when a generation was refused for insufficient credits. Rendering/export is a separate, hour-based limit (not credits) — shown alongside the AI credit balance.

Inputs: no named parameters.

arsaze_show_generated_assetA
Read-only
Inspect

Display ONE finished generation as a playable, downloadable card.

Use this instead of pasting a URL into the chat once a video_gen /
image_gen / voice job is done — the user gets an inline player and a
real Download button rather than a link they have to copy. Works for a
job that is still running too: it shows the live status instead of a
result.

For several results at once, use arsaze_show_generated_results.

Inputs: job_id (required).

arsaze_show_generated_resultsA
Read-only
Inspect

Display SEVERAL finished generations together as one grid, each downloadable.

Use this whenever a single request produced more than one result — a batch image generation returns one job id per image, and showing them as separate cards floods the conversation. Pass every job id from the batch; ones still running show as pending rather than being dropped, so the user can see the whole set.

Inputs: job_ids (required).

arsaze_toolsA
Read-onlyIdempotent
Inspect

Arsaze's tool catalogue — served on demand instead of loaded up front.

No arguments: every tool name, grouped by domain (a table of contents).
names=[...]: exact signatures + parameter docs for those tools — do this before the first arsaze_call to a tool.
query='split a clip': the best-matching tools — and workspace files, for reads — best first.
Signatures read `param?: type` for optional params. Reads are not tools — they're files (ws_ls).

Inputs: names, query. Returns: result

media_lookA
Read-only
Inspect

SEE the footage: decoded frames come back as an image you can look at. Give asset_id to look at one clip's source (times in source seconds), or leave it out to look at the timeline (times in timeline seconds; each frame is the top visible clip under the playhead). Pass times=[...] for exact moments, or start_s/end_s/count to sample a range (max 12). Several frames come back as one numbered contact sheet. Use it to check who is on camera, framing, a bad frame, which angle is which. Check already_noted first: if another agent wrote down what's there, you may not need to look. After looking, save what you learned with media_note. On a local project a timeline look is the FINISHED picture by default (as the preview shows it: zoom and position in the output frame, stacked tracks, transparency, Animate scenes; drawn by the desktop app; captions, shapes, grades and effects listed in words as not drawn). finished=false, a cloud project, or the desktop app being unavailable gives each clip's raw source frame instead, with a framing note saying which part of it the video shows. compare_revision=N also draws revision N of the timeline beside it (before | now).

response_detail (summary|ids|compact|full), fields (dotted paths), cursor (next page) — see the server instructions.

Inputs: count, end_s, sheet, times, +9 more.

run_timeline_batchA
Idempotent
Inspect

Run MULTIPLE timeline-tool calls in ONE request, where a LATER step can reference a value produced by an EARLIER step in the SAME batch — the fix for 'split this clip, then move just the second half': you don't know the new second-half clip's id until AFTER the split has actually run, so normally that needs two separate turns. In a batch, give the split step a step_id (e.g. "step1"), and reference its result in a later step's args as a string like "$step1.timeline.tracks.0.clips.-1.id" (dotted path into that step's own JSON result; a numeric segment like -1 indexes into a list, -1 = the last item — the newest clip on a track after a split/add is always last). tracks.N here is ordered by (video/overlay tracks first, then audio; ascending index within each) — NOT by when the track was created — so tracks.0 reliably means 'the lowest-index video track' even if an empty leftover track exists elsewhere. Every step's result also carries new_clip_ids and removed_clip_ids (what that step created or removed), so "$step1.new_clip_ids.0" names the clip a split/add/duplicate made without any positional path. Still, prefer referencing a clip/track by its literal id once you have one (e.g. from an earlier step's own new_clip_ids, clip_ids or a job/<job_id>/timeline.txt call) over a tracks.N/clips.N positional path when you're not certain which position you mean — positional indexing is a convenience for the common 'the track/clip I just touched' case, not a stable general-purpose address. Every step's tool must be a real timeline tool name (job/<job_id>/timeline.txt first if you need to see a tool's exact result shape before referencing it). All-or-nothing: the first step that fails stops the whole batch immediately and later steps never run — check each entry in the response's step_results for where it stopped. Use this whenever a plan has TRUE ordering dependencies (step 2 needs data step 1 just created); for independent clips with no cross-references, add_clips_to_timeline is simpler.

Inputs: steps (required), job_id (required), fields, response_detail.

screen_actA
Idempotent
Inspect

Do one thing on the page or app, like a person would: the pointer travels to what it clicks, fields are clicked before typing, scrolling uses the wheel; then a fresh look (no screenshot unless asked). action: click | double_click | hover | type | press | scroll | navigate | back | wait | say | focus | unfocus | highlight | hide | unhide. Prefer ref from the latest look over x/y. You edit the take as you record it: the cut is finished the moment you stop, so decide everything here. While recording, use action 'say' with text before each step to narrate it (it becomes a caption and a timed line of the saved script, ready to be voiced). To show something off (a result, a chart, a setting), use action 'focus' with its ref, several refs framed together, or an exact area x, y, w, h (it fills the view); pad adds room, zoom 1.1-4 says how close outright, seconds how long: the take's camera zooms in and holds that long, or until the next focus or 'unfocus' (nothing on the page changes); without it the camera follows your clicks and typing. The result's shots gives each focus's zoom and view (the part of the page in frame, CSS pixels): check it and focus again if it is not what a viewer should see. Before recording, a focus only reports its shot: rehearse your framing. To point out or copy words, use action 'highlight' with the ref and the text in it, and color, seconds, lift, zoom_in if you like: the words are selected by a drag (press Control+C, Meta+C on a Mac, to copy) and the take marks them, lifted off the page (in an app the element is marked, nothing is selected). To keep something private (an e-mail, a key, a customer's name), use action 'hide' with its ref (and the text in it to hide only those words), or an area x, y, w, h: it is blurred in the take from then, following it as the page scrolls, until 'unhide' (with the ref, or none for everything); hidden before recording, it is hidden from the first frame. While recording every result says at: the take's clock in seconds. Pass steps (a list of these same objects, max 40) to run several in a row. In an app, if the user moves the mouse you are stopped: ask them, then pass resume=true.

response_detail (summary|ids|compact|full), fields (dotted paths), cursor (next page) — see the server instructions.

Inputs: h, w, x, y, +23 more.

screen_closeC
Idempotent
Inspect

Close the recorded browser and let go of any app (a take still recording is thrown away).

response_detail (summary|ids|compact|full), fields (dotted paths), cursor (next page) — see the server instructions.

Inputs: cursor, fields, response_detail.

screen_hand_overA
Idempotent
Inspect

Hand the open page to the USER for something only they should do (sign in, enter a code, accept a prompt) and wait. They see the page large in the Arsaze window, type into it there and press Done. You never see what they typed: those fields read as secret in screen_look and show as dots in screenshots and takes. Nothing is recorded meanwhile. Returns done: true when they finished (then screen_look), or done: false (cancelled or timed out: ask them before trying again). Web pages on the desktop app only; in one of their own apps they simply type it themselves.

response_detail (summary|ids|compact|full), fields (dotted paths), cursor (next page) — see the server instructions.

Inputs: reason (required), ref, cursor, fields, +2 more.

screen_list_appsB
Read-only
Inspect

Windows and macOS: the apps open on the user's computer (hwnd, title, app, whether in front), to pick one for screen_open_app. If the app you need isn't there, ask the user to open it. On a Mac, shortcuts use Meta (Command): Meta+C copies.

response_detail (summary|ids|compact|full), fields (dotted paths), cursor (next page) — see the server instructions.

Inputs: cursor, fields, response_detail.

screen_loginA
Idempotent
Inspect

Open a window on the user's screen, in the recorded browser's own profile, for the USER to sign in to a site. Tell the user to sign in and close it, then screen_open the page again: the browser stays signed in. You never see what they type.

response_detail (summary|ids|compact|full), fields (dotted paths), cursor (next page) — see the server instructions.

Inputs: url (required), cursor, fields, response_detail.

screen_lookA
Read-only
Inspect

See the page or app you opened: every element a person could act on (ref, role, name, box; a field's value, never a password), the headings, scroll, and a screenshot. Refs are valid until the next look.

response_detail (summary|ids|compact|full), fields (dotted paths), cursor (next page) — see the server instructions.

Inputs: cursor, fields, screenshot, response_detail.

screen_openA
Idempotent
Inspect

Open a web page in the browser Arsaze records, on the user's computer (its own profile, not the user's sign-ins). Returns the page: elements to act on with refs, headings, scroll, and a screenshot. width x height is the page in CSS pixels; the video is that times scale (default 1280x720 at 1.5 = 1920x1080). Nothing is recorded until screen_record_start.

response_detail (summary|ids|compact|full), fields (dotted paths), cursor (next page) — see the server instructions.

Inputs: url (required), scale, where, width, +4 more.

screen_open_appA
Idempotent
Inspect

Take one of the user's apps for a demo, with the REAL mouse and keyboard while the user watches: brings its window to the front (maximised unless maximize=false) and returns what can be acted on (refs, roles, names, boxes in pixels from the window's top-left) with a screenshot. From now on screen_look, screen_act and screen_record_* work on this app. If the user moves the mouse, you are stopped.

response_detail (summary|ids|compact|full), fields (dotted paths), cursor (next page) — see the server instructions.

Inputs: hwnd, title, cursor, fields, +2 more.

screen_record_startA
Idempotent
Inspect

Start recording the page or app you opened. Rehearse the flow first; from here every action is in the take. Between your calls the take holds still, so thinking time never shows. Set the cut's look here (style, aspect, cursor, highlight_color, auto_zoom, captions…): you are the editor, and the take is cut in this look the moment it stops. screen_record_stop can still change any of it.

response_detail (summary|ids|compact|full), fields (dotted paths), cursor (next page) — see the server instructions.

Inputs: frame, style, title, aspect, +22 more.

screen_record_stopA
Idempotent
Inspect

Stop recording. Arsaze cuts the take like a person's (zooms on clicks and typing, captions from your narration, waiting cut out, private details blurred), renders it, and puts it on the timeline of a NEW project (on the user's computer, private) with video/audio analysis off. Returns project_id, job_id, asset_id, clip_id and the editor link, plus what the edit did. Continue editing that job with the usual timeline tools. Also returns steps: the take as numbered steps, ready to turn into written docs, and script: the narration and steps timed in the finished video's seconds (saved with the project, ready to be voiced line by line). The look is what you set at screen_record_start, with anything you set here over it: style (midnight | clean | bold | plain), aspect (16:9; 9:16 for Shorts, Reels and TikTok; 1:1; 4:3), callouts, title_card, cursor, highlight_color, auto_zoom, captions and the rest. The cut is final when this returns; the take also opens in Arsaze Recorder for the user.

response_detail (summary|ids|compact|full), fields (dotted paths), cursor (next page) — see the server instructions.

Inputs: frame, style, aspect, cursor, +21 more.

screen_resultA
Read-only
Inspect

The result of a screen_* call that came back still running (waiting for the user to allow it, or screen_record_stop still cutting and rendering): pass its command_id. Returns what that call would have.

response_detail (summary|ids|compact|full), fields (dotted paths), cursor (next page) — see the server instructions.

Inputs: command_id (required), cursor, fields, response_detail.

screen_statusB
Read-only
Inspect

Can you record a demo on the user's computer right now? Call first. Says whether the Arsaze desktop app is connected, its platform, and whether it can drive the user's own apps (Windows, macOS) or only web pages. How it works: screen_open a page (or screen_list_apps + screen_open_app), screen_look / screen_act to rehearse, screen_record_start, perform the flow narrating each step with action 'say', screen_record_stop: Arsaze cuts the take (zooms, captions, dead time removed) and puts it on a new project's timeline. The user approves in Arsaze before anything is opened.

response_detail (summary|ids|compact|full), fields (dotted paths), cursor (next page) — see the server instructions.

Inputs: cursor, fields, response_detail.

ws_editAInspect

Edit the project by editing its files — exact old→new replacement, like editing code. job/<job_id>/transcript.txt, transcript/<clip_id>.txt, words/<clip_id>.txt: delete words, phrase lines or pause lines to CUT them from the edit. job/<job_id>/timeline.txt: delete a clip line (remove clip), change its start (move), move the line under another track header (change track), change its src range (trim) or x. project/<project_id>/scenes/<scene_id>/document.html: any edit. Applied as ONE undoable, all-or-nothing batch. dry_run=true returns the operations without applying. keep_tracks_in_sync=true (transcript cuts only): in the same edit, overlays, cutouts, captions, sound effects and music after the cut move with the footage they sat over. old must be copied exactly from a fresh ws_read.

Inputs: new (required), old (required), path (required), confirm, +3 more.

ws_grepA
Read-onlyIdempotent
Inspect

Search a workspace file (or a per-clip / per-link directory such as job/<job_id>/words) with a regex; returns path:line:text for each hit. context = lines shown around each hit (max 5).

Inputs: path (required), pattern (required), context, ignore_case. Returns: result

ws_lsA
Read-onlyIdempotent
Inspect

List workspace files. '' shows the whole layout; 'job/<job_id>' or 'project/<project_id>' lists that scope's files; 'job/<job_id>/transcript' (or words, review/shares) lists one file per clip/link.

Inputs: path. Returns: result

ws_readA
Read-onlyIdempotent
Inspect

Read a workspace file with line numbers — e.g. projects.txt, job/<job_id>/timeline.txt, job/<job_id>/review/brief.txt, project/<project_id>/assets.txt. At most ~250 lines per call; pass start_line/end_line (1-based, inclusive) for a range. Grep first on long files.

Inputs: path (required), end_line, start_line. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      B
      maintenance
      AI-native timeline editor for short-form video. Your agent cuts, captions, adds motion graphics and renders against a real, editable timeline over MCP — not a render queue. Human-in-the-loop by design: it calls request_review and waits while you supervise in a browser. Local-first and AGPL; your footage never leaves your machine.
      2
      AGPL 3.0
    • A
      license
      Not graded
      quality
      B
      maintenance
      Valmera, the world’s most advanced AI video editor, edits your recorded footage through Claude, ChatGPT or another MCP client. Place your own B-roll on a spoken word, correct a caption, cut or reframe a shot, review the preview and export an MP4. Watch both four-second edits in the README. Hosted editing requires an eligible paid Valmera plan.
      MIT
    Try in Browser

    Glama MCP Gateway

    Add one secure layer between your agents and this server.