SkillAgentSearch skills...

scenario-text-overlay

Use when text must appear letter-perfect on generated media: taglines, CTAs, prices, legal supers, lower thirds, end cards, nameplates, or styled rich cards composited over Scenario images and video.

Install / Use

npx skills add scenario-labs/skills --skill scenario-text-overlay

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

86/100

Category

Legal

Supported Platforms

Universal

Our assessment of scenario-text-overlay

scenario-text-overlay scores 86/100 on our quality scale, 102nd of 209 Legal skills we index (top 49%).

Its SKILL.md is 7.0 KB long, split into 6 sections with 1 code example: a thorough specification that gives an agent plenty to work with.

With 1,048 GitHub stars, it is one of the more widely adopted skills in the catalogue.

Substance
29/30
Structure
15/20
Description
15/15
Adoption
13/20
Freshness
15/15

Maintenance, license and trust

  • The repository was last updated 29 days ago, so scenario-text-overlay is actively maintained.
  • It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
  • Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-11-10. Automated pattern scan on 2026-11-10. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.

scenario-text-overlay compared with similar skills

All 4 of these similar skills score higher than scenario-text-overlay; compare them before choosing.

SkillScoreStarsUpdatedFormat
scenario-text-overlay (this skill)by scenario-labs861.0k29d agoSKILL.md
taste-skillby Leonxlnx100116.8k8d agoCLAUDE.md
LocalAIby mudler10050.4ktodayMCP Server
x402by browser-use100121.0k3d agoSKILL.md
algorithmic-artby anthropics100177.9k55d agoSKILL.md

Frequently asked questions

How do I install scenario-text-overlay?
Run npx skills add scenario-labs/skills --skill scenario-text-overlay. The install tabs above show the steps for each supported agent.
Which AI agents does scenario-text-overlay work with?
It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
Is scenario-text-overlay safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is MIT-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is scenario-text-overlay still maintained?
The repository was last updated 29 days ago, so scenario-text-overlay is actively maintained.

name: scenario-text-overlay description: "Use when text must appear letter-perfect on generated media: taglines, CTAs, prices, legal supers, lower thirds, end cards, nameplates, or styled rich cards composited over Scenario images and video. Keywords: text overlay, text card, caption card, CTA, legal super, tagline, end card, lower third, price card, HUD text, transparent PNG." license: MIT

Scenario Text Overlay

Overview

Generation models drift on type, so text that must be exact is rendered deterministically here and composited over the media. One JSON payload describes one overlay, in one of two kinds: a text layer (plain styled text in a box) or a rich layer (HTML/CSS typography: gradients, strokes, shadows, card layouts). Both substitute Mustache {{variables}} strictly (a missing variable fails the render) on a transparent canvas.

scripts/overlay.py renders the payload to a PNG with an installed Chromium-family browser (both kinds, discovered automatically) or a Pillow fallback (text layers only), embeds the payload JSON into the PNG, and prints the path. Its modules: scripts/templating.py (strict Mustache), scripts/html_render.py (browser engine), scripts/pillow_render.py (fallback). The field-by-field contract and example payloads live in references/payloads.md. The script needs pip install chevron pillow.

Connection and the core MCP loop: see the scenario skill. The overlay meets its content on the platform, never locally: model_run on the compose tool models, model_scenario-compose-image for stills and model_scenario-compose-video for video (fixed ids: each is Scenario's single deterministic compositor for its medium, so discovery would only re-derive them), whose layer contract lives in scenario-video-assembly. If a sibling skill named here is missing from your available skills, load it with skill_get (Scenario MCP) or ask the user to install it (https://github.com/scenario-labs/skills#install); unattended, proceed from tool schemas and flag the gap.

Quick reference

| Step | Detail | | ----------------------- | ---------------------------------------------------------------------------------------------------- | | 1. Write the payload | Kind by field (text_template or html_template); every changeable string in variables | | 2. Render | python3 overlay.py --payload card.json --out card.png | | 3. Verify | Open the PNG: glyphs verbatim, box placement right, background transparent | | 4. Upload | upload_asset (kind image, multipart path) | | 5. Persist the template | asset_update sets metadata.description to the payload JSON; asset_add_tags adds text-overlay | | 6. Composite | model_run on model_scenario-compose-image or model_scenario-compose-video, overlay on top |

Choose the face for its meaning

The face is part of the message: heavy condensed sans shouts (hooks, prices, CTAs), light geometric or grotesque sans reads neutral and premium (legal supers, lower thirds, nameplates), serif signals editorial or heritage weight, rounded forms read friendly and casual. Match the media's art direction rather than fighting it, keep one family per card, and build hierarchy with font_weight (100 to 900) and size instead of mixing faces. font_family reaches any Google Fonts family, so every class above is available by name; a contractual brand face rides font_url instead. Meaning survives only above legibility, so judge the flattened preview at destination size, where a subtle face turns generic.

Worked example: a localized legal super

  1. Payload, with the changeable line as a variable:
{
  "text_template": "{{disclaimer}}",
  "variables": [
    {
      "key": "disclaimer",
      "value": "EPA-estimated 310 mi. Actual range varies."
    }
  ],
  "font_family": "Inter",
  "font_weight": 500,
  "size": 34,
  "color": "#FFFFFF",
  "align": "center",
  "bbox": [{ "x": 86, "y": 1560, "w": 908, "h": 120 }],
  "canvas_width": 1080,
  "canvas_height": 1920,
  "overflow": "shrink"
}
  1. python3 overlay.py --payload super.json --out super.png, then open super.png: the line must read exactly as written, shrunk to fit the box.
  2. Upload with upload_asset, then asset_update with the payload JSON as metadata.description and asset_add_tags with ["text-overlay"] (asset_update's own metadata.tags replaces the whole set): the template now lives on the platform beside its render, and the PNG itself carries it in a tEXt chunk.
  3. Composite over the spot: model_schema_get on model_scenario-compose-video, then model_run with the base video at zIndex 0 and the super as an image layer above it (layer fields: scenario-video-assembly); jobs_wait, then asset_display.
  4. The French variant is the same payload with one value edited, never a new template.

Common mistakes

  • Baking changeable strings into the template: variants and localizations should be edits to variables; the uploaded payload is the reproducibility contract.
  • Using {{var}} for values holding &, <, or >: it HTML-escapes, so they render as literal entity text; {{{var}}} is the raw opt-out (full Mustache rules: the payload reference).
  • Leaving images or fonts as remote URLs: inline them as data: URIs (Google Fonts links excepted) or the render depends on the network and drifts.
  • Skipping the visual check before upload: font resolution differs per machine, and light text on the transparent canvas previews as blank; flatten over a contrasting backdrop first.
  • Letting a generation model paint the text instead: generated type drifts frame to frame; overlays exist to avoid exactly that.
  • Generating the plate with no room for the card: brief the base image or video with the overlay's zone kept plain and text-free (a dark right third, an empty top band) for every frame the card is up, so the composite lands on quiet pixels rather than generated lettering or detail.
  • Merging the overlay locally with Pillow or ffmpeg: compositing is a model_run on the compose models, so the finished creative lands on the platform beside its layers.
  • Sizing the canvas to something other than the destination: match the target resolution so the overlay composites 1:1 with no post-scale blur. Content layers may scale inside the compose run when a generation model cannot hit the exact size; the overlay must not.
  • Expecting the fallback to match the browser: Pillow draws plain text only; rich layers need a Chromium-family browser installed.
  • Trusting wrap with a hard box: it lets text spill below; use shrink (fits or fails loudly) or clip when the box is binding.

Related Skills

View on GitHub
GitHub Stars1.0k
CategoryLegal
Updated29d ago
Forks129

Languages

Python

Trust signals

100/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

No cautions
scenario-text-overlay — Universal Skill: Install & Safety Check | SkillAgent