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-overlayInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
LegalSupported Platforms
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.
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 foundOur 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.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| scenario-text-overlay (this skill)by scenario-labs | 86 | 1.0k | 29d ago | SKILL.md |
| taste-skillby Leonxlnx | 100 | 116.8k | 8d ago | CLAUDE.md |
| LocalAIby mudler | 100 | 50.4k | today | MCP Server |
| x402by browser-use | 100 | 121.0k | 3d ago | SKILL.md |
| algorithmic-artby anthropics | 100 | 177.9k | 55d ago | SKILL.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.
Skill content
View source on GitHubname: 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
- 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"
}
python3 overlay.py --payload super.json --out super.png, then opensuper.png: the line must read exactly as written, shrunk to fit the box.- Upload with
upload_asset, thenasset_updatewith the payload JSON asmetadata.descriptionandasset_add_tagswith["text-overlay"](asset_update's ownmetadata.tagsreplaces the whole set): the template now lives on the platform beside its render, and the PNG itself carries it in atEXtchunk. - Composite over the spot:
model_schema_getonmodel_scenario-compose-video, thenmodel_runwith the base video atzIndex0 and the super as an image layer above it (layer fields:scenario-video-assembly);jobs_wait, thenasset_display. - The French variant is the same payload with one
valueedited, 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_runon 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
wrapwith a hard box: it lets text spill below; useshrink(fits or fails loudly) orclipwhen the box is binding.
Related Skills
taste-skill
116.8kAgent skills that give coding agents taste: art direction, reference images and a browser check instead of generic AI pages
LocalAI
50.4kLocalAI is the open-source AI engine. Run any model - LLMs, vision, voice, image, video - on any hardware. No GPU required.
x402
121.0kSet up Browser Use Cloud payments with x402 — pay per request from a crypto wallet (USDC on Base mainnet), no signup or API key.
algorithmic-art
177.9kCreating algorithmic art using p5.js with seeded randomness and interactive parameter exploration. Use this when users request creating art using code, generative art, algorithmic art, flow fields, or particle systems.
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
