# Tegas AI (remote · api.tegas.ai)

AI video production for marketing and social media: script, scenes, voice-over, subtitles, music.

- Trust score: 38/100 (low)
- Change this week: 0
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-10-04

## Components

- remote · `api.tegas.ai`: 38/100 (this document), [markdown](https://verifymcp.io/servers/ai-tegas-video/api.md), [page](https://verifymcp.io/servers/ai-tegas-video/api)

## Channel facts

- Endpoint: `https://api.tegas.ai/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `1.1.1`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-10-04.

- **Endpoint Security**: 94/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - The endpoint enforces authorisation, advertised via RFC 9728 protected-resource metadata.
  - HTTPS is enforced; there's no plaintext access path.
  - The HSTS (Strict-Transport-Security) header is present.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
  - The authorisation server offers only Dynamic Client Registration (RFC 7591), which MCP 2026-07-28 deprecated in favour of Client ID Metadata Documents.
- **Transport & Reachability**: 0/100
  - Transport blocked by authentication: the endpoint requires auth we don't have to verify streamable-http.
- **Schema Quality & AI Usability**: 0/100
  - Schema blocked by authentication: the endpoint requires auth we don't have to read it.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 0/100
  - Tool coverage blocked by authentication: the endpoint requires auth we don't have to read its tools.
- **Tool Safety**: 0/100
  - Tool safety blocked by authentication: the endpoint requires auth we don't have to read its tools.
- **Capabilities**: 0/100
  - Capabilities blocked by authentication: the endpoint requires auth we don't have to read them.

**Unverified: 6 categories.** Categories scored 0 because we could not verify them: authentication we do not have, an unreachable endpoint, or not enough scan history. We only credit what we can confirm.

## Install

### How do I install the Tegas AI MCP server?

Tegas AI is a hosted endpoint at https://api.tegas.ai/mcp, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add --transport http ai-tegas-video 'https://api.tegas.ai/mcp'
```

### Cursor

```json
{
  "mcpServers": {
    "ai-tegas-video": {
      "url": "https://api.tegas.ai/mcp"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "ai-tegas-video": {
      "type": "http",
      "url": "https://api.tegas.ai/mcp"
    }
  }
}
```

### Codex

```toml
[mcp_servers.ai-tegas-video]
url = "https://api.tegas.ai/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "ai-tegas-video": {
      "type": "remote",
      "url": "https://api.tegas.ai/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add ai-tegas-video --url 'https://api.tegas.ai/mcp' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  ai-tegas-video:
    url: "https://api.tegas.ai/mcp"
```

### Netclaw

```json
{
  "McpServers": {
    "ai-tegas-video": {
      "Transport": "http",
      "Url": "https://api.tegas.ai/mcp"
    }
  }
}
```

### Vellum

```bash
assistant mcp add ai-tegas-video -t streamable-http -u 'https://api.tegas.ai/mcp'
```

### Other

```json
{
  "mcpServers": {
    "ai-tegas-video": {
      "type": "http",
      "url": "https://api.tegas.ai/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-09-28 (score 38, 0)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-09-25 (score 38, 0)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-09-16 (score 38, 0)

- [security regression] Endpoint reachability: reachable → behind authorisation

### 2026-09-15 (score 38)

First indexed and scored.

## MCP tools (12)

### `tegas_account` (~147 tokens)

Account and prices

Free. Account overview: token balance, whether a plan is active, rate limits and the current
    price in tokens per second of video for each quality (480p/720p/1080p). Call this first to know
    the balance, and before starting a video to compute price = tokens_per_second[quality] * duration_sec.
    If plan.active is false, POST-type tools (scenario, heroes, video) will fail with no_active_plan:
    tell the user to activate a plan in the Tegas cabinet. If the balance is lower than a price,
    the start will fail with insufficient_tokens: tell the user to top up tokens in the cabinet.

### `tegas_voices` (~80 tokens)

List voices

Free. List voice-over voices for a language (ru, en, es, fr, de). Each item has an `id`
    that can be passed as `voice` to tegas_start_video; when `voice` is omitted the default
    natural voice is used, so calling this is optional.

Input parameters:

- `language` (string)

### `tegas_upload_reference` (~419 tokens)

Upload a reference image

Free (requires an active plan). Upload one reference image and get a `reference_id` to reuse:
    a product photo, a character, a brand shot. Give exactly one of image_base64 or file_path.
    image_base64 - the image bytes as base64 (a `data:image/png;base64,...` URL is also accepted);
    this is the way for any remote agent, because the image never has to be public.
    file_path - a path on the FILESYSTEM OF THE MCP SERVER, so it only works for local / self-hosted
    runs where the server and the agent are on the same machine, and only when the server enables it
    (otherwise the tool answers with code local_files_disabled - then send image_base64 instead).
    Formats jpeg, png, webp, heic, up to 10 MB, shorter side at least 360 px, longer at most 4096 px.
    Bad input comes back as validation_error with details.reason, before anything is uploaded:
    one_source_required (gave both or neither), bad_base64, empty, not_image, too_small,
    too_large_dimensions, too_large; a file_path that cannot be read is file_not_readable, and a
    server that forbids local files answers with code local_files_disabled.
    label - a short note (e.g. "hero", "product"), optional, kept to the first 120 characters.
    Returns reference_id, the stored url, the label and a model-written description. The reference
    expires together with scenarios (the server's scenario TTL, 7 days by default), so upload it
    again for a later video. Pass the returned reference_id in `reference_urls` of
    tegas_write_scenario or tegas_start_video - no public link needed.
    Errors: no_active_plan -> ask the user to activate a plan in the cabinet.

Input parameters:

- `file_path`
- `image_base64`
- `label` (string)

### `tegas_upload_music` (~361 tokens)

Upload a music track

Free (requires an active plan). Upload one music track and get a `url` to reuse in
    tegas_edit_video's `music.url`. Give exactly one of audio_base64 or file_path.
    audio_base64 - the audio bytes as base64 (a `data:audio/mpeg;base64,...` URL is also accepted);
    this is the way for any remote agent, because the file never has to be public.
    file_path - a path on the FILESYSTEM OF THE MCP SERVER, so it only works for local / self-hosted
    runs where the server and the agent are on the same machine, and only when the server enables it
    (otherwise the tool answers with code local_files_disabled - then send audio_base64 instead).
    Formats mp3, wav, m4a, up to 25 MB.
    Bad input comes back as validation_error with details.reason, before anything is uploaded:
    one_source_required (gave both or neither), bad_base64, empty, not_audio, too_large; a file_path
    that cannot be read is file_not_readable, and a server that forbids local files answers with code
    local_files_disabled.
    label - a short note (e.g. "background track"), optional, kept to the first 120 characters.
    Returns music_id, the stored url, the label and expires_at. Pass the returned url in
    `music.url` of tegas_edit_video (and set `music.enabled` to true if music was off).
    Errors: no_active_plan -> ask the user to activate a plan in the cabinet.

Input parameters:

- `audio_base64`
- `file_path`
- `label` (string)

### `tegas_write_scenario` (~250 tokens)

Write a scenario

Free (requires an active plan). Tessa writes a complete video scenario from an idea in one
    call, without asking questions. duration_sec 5..60, aspect 9:16 | 16:9 | 1:1. reference_urls:
    public image URLs of a product/character (or reference_id `ref_...`), optional.
    Returns scenario_id (valid for a few days), the scenario text, episodes with per-episode
    durations, warnings and the actual duration_sec (may differ from the requested one).
    Typical flow: tegas_write_scenario -> (optional) tegas_find_heroes / tegas_draw_heroes ->
    tegas_start_video with confirm=false to get the price -> user consent -> confirm=true ->
    tegas_wait_video. Keep the returned duration_sec: pass it to tegas_start_video for the quote.
    Show the scenario text to the user; call again with a refined idea if they want changes.

Input parameters:

- `aspect` (string)
- `category`
- `duration_sec` (integer)
- `idea` (string, required)
- `language` (string)
- `reference_urls`

### `tegas_find_heroes` (~135 tokens)

Find recurring heroes

Free (requires an active plan). Brief of recurring characters and the hero product of a
    scenario: up to 3 items with `index`, kind (character/object), name and an image prompt,
    plus price_each_tokens - the price of drawing one hero sheet. Hero sheets keep a character
    consistent across all episodes of the video. style: photorealistic | 3d_cartoon | 2d_animation
    | anime (omit to follow the scenario). Drawing is a separate paid step: tegas_draw_heroes.

Input parameters:

- `scenario_id` (string, required)
- `style`

### `tegas_draw_heroes` (~242 tokens)

Draw hero sheets

PAID. Draw hero sheets for the brief items chosen by `index` (from tegas_find_heroes, up to 3).
    Cost = price_each_tokens x number of items; pass price_each_tokens from tegas_find_heroes to
    avoid recomputing the brief. With confirm=false (default) nothing is drawn: the tool returns
    needs_confirmation=true and the price - show it to the user and ask for consent. Only after an
    explicit "yes" call again with confirm=true. Drawn sheets are attached to the scenario and used
    automatically by tegas_start_video with the same scenario_id. The result carries idempotency_key:
    if the call times out or fails with a network error, retry with the same idempotency_key - never
    start twice without it. On insufficient_tokens ask the user to top up; on no_active_plan ask them
    to activate a plan in the cabinet.

Input parameters:

- `confirm` (boolean)
- `idempotency_key`
- `items` (array, required)
- `price_each_tokens`
- `scenario_id` (string, required)

### `tegas_start_video` (~383 tokens)

Start a video

PAID. Start rendering a video from a Tessa scenario (scenario_id) or your own scenario_text -
    exactly one of them. Cost = tokens_per_second[quality] x duration_sec (see tegas_account);
    pass duration_sec returned by tegas_write_scenario so the quote is exact. With confirm=false
    (default) nothing is started: the tool returns needs_confirmation=true with the price and the
    balance - show them to the user and ask for consent. Only after an explicit "yes" call again with
    confirm=true; it then starts the render and returns video_id with status queued plus the
    idempotency_key used. If the call times out or fails with a network error, retry with the same
    idempotency_key (it makes the retry free of double charge); never start twice without it.
    Then call tegas_wait_video.
    quality 480p | 720p | 1080p; voice - id from tegas_voices (omit for the default); music,
    subtitles (style tiktok | phrases | contrast); reference_urls - product/character images;
    watermark - the Tegas watermark on the finished video, omit to keep the account default.
    Errors: insufficient_tokens -> ask the user to top up in the cabinet; no_active_plan -> ask them
    to activate a plan; rate_limited with details.active -> wait for a running video to finish.

Input parameters:

- `confirm` (boolean)
- `duration_sec`
- `idempotency_key`
- `music` (boolean)
- `quality` (string)
- `reference_urls`
- `scenario_id`
- `scenario_text`
- `subtitle_style` (string)
- `subtitles` (boolean)
- `voice`
- `watermark`

### `tegas_video_status` (~56 tokens)

Check video status

Free. Status of one video: queued | processing | completed | failed, progress 0..100,
    file_url when completed, error when failed (tokens are refunded automatically on failure).

Input parameters:

- `video_id` (string, required)

### `tegas_wait_video` (~93 tokens)

Wait for a video

Free. Wait for a video: polls the status every 10 s until completed (returns file_url),
    failed (returns error; tokens are refunded) or timeout_sec elapses (returns the last status with
    timed_out=true - call again to keep waiting). A 20-30 s video usually takes a few minutes.

Input parameters:

- `timeout_sec` (integer)
- `video_id` (string, required)

### `tegas_list_videos` (~51 tokens)

List recent videos

Free. The user's most recent videos (newest first, limit 1..100) with status, file_url,
    price_tokens, quality and scenario_id.

Input parameters:

- `limit` (integer)

### `tegas_edit_video` (~630 tokens)

Edit a finished video

Free (no tokens charged). Edit a finished video in place and rebuild it: this REPLACES the
    whole video end to end and typically takes a few minutes, the same as the original render - it
    is not a quick patch. Tell the user what you are about to change before calling this, then poll
    with tegas_wait_video (or tegas_video_status) after the call; do not call this again for the
    same video until the rebuild finishes.

    Pass at least one of the groups below; omit a group entirely to leave it untouched:
    - scenes: list of {"index": int, "voiceover_text"?: str, "subtitles_text"?: str, "video_url"?: str}
      - one entry per scene to change, each needs at least one of the three fields.
    - voice: {"id"?: str, "gender"?: "female"|"male", "language"?: "ru"|"en"|"es"|"fr"|"de"} -
      changing any of id/gender/language RE-VOICES EVERY SCENE that has voice-over text, not just
      the ones listed in `scenes`.
    - subtitles: {"enabled"?: bool, "style"?: "tiktok"|"phrases"|"contrast",
      "appearance"?: {"alignment"?, "font_size"?, "font_family"?, "text_color"? (hex "#RRGGBB"),
      "color_saturation"?}} - you cannot disable subtitles and set their style/appearance in the
      same call, that fails with 422 validation_error; disable them in one call and restyle in a
      later one.
    - music: {"enabled"?: bool, "url"?: str} - url must come from tegas_upload_music (or another
      public https URL).
    - volumes: {"voice"?: int, "music"?: int, "master"?: int} - each 0..100.
    - watermark: bool - the Tegas watermark on the finished video. Must be the ONLY change in the
      call, not combined with scenes/voice/subtitles/music/volumes: the renderer rebuilds the
      watermark through a separate step, so mixing it with other changes fails with 422
      validation_error. Change the watermark in its own call.

    Returns video_id, status "processing" and edits_accepted - the list of groups that were actually
    applied (e.g. ["voice", "subtitl…

Input parameters:

- `music`
- `scenes`
- `subtitles`
- `video_id` (string, required)
- `voice`
- `volumes`
- `watermark`

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/ai-tegas-video/api#diagnostics

## Score history

- 2026-10-04: 38
- 2026-10-03: 38
- 2026-10-02: 38
- 2026-10-01: 38
- 2026-09-30: 38
- 2026-09-29: 38
- 2026-09-28: 38
- 2026-09-27: 38
- 2026-09-26: 38
- 2026-09-25: 38
- 2026-09-24: 38
- 2026-09-23: 38
- 2026-09-22: 38
- 2026-09-21: 38
- 2026-09-20: 38
- 2026-09-19: 38
- 2026-09-18: 38
- 2026-09-17: 38
- 2026-09-16: 38
- 2026-09-15: 38

## Common questions

### What is the Tegas AI MCP server?

Tegas AI is an MCP server listed in the public MCP registry as ai.tegas/video. AI video production for marketing and social media: script, scenes, voice-over, subtitles, music. This page covers its hosted endpoint (https://api.tegas.ai/mcp).

### Is the Tegas AI MCP server safe to use?

Tegas AI scores 38 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Tegas AI MCP server expose?

Tegas AI exposes 12 tools: tegas_account, tegas_voices, tegas_upload_reference, tegas_upload_music, tegas_write_scenario, and 7 more. Their descriptions and schemas cost roughly 2,847 tokens of context every time the server is loaded.

### Does the Tegas AI MCP server require authentication?

Yes. Tegas AI asked us for credentials when we connected, so you will need to authorise it in your MCP client before it can do anything.

### Is the Tegas AI MCP server still maintained?

Tegas AI is still listed as active in the MCP registry. We last reached this channel on 4 October 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

## Links

- Remote endpoint: https://api.tegas.ai/mcp
- Repository: https://github.com/ITtegasai/tegas-mcp
- Website: https://docs.tegas.ai/
- Changelog RSS feed: https://verifymcp.io/servers/ai-tegas-video/api.xml
- Changelog JSON feed: https://verifymcp.io/servers/ai-tegas-video/api.json
- HTML version of this page: https://verifymcp.io/servers/ai-tegas-video/api