Rengi Forge

sprite_tools_video_to_sheet

Turn an animation video or GIF (from Kling, Veo, Sora or a capture) into a sprite sheet: frames at your fps, background removed, every frame aligned to one box and pivot so it does not jitter, the best loop point, TexturePacker JSON, Godot SpriteFrames and a GIF preview. Price: $0.15 USDC via x402, charged only on success. Part of Sprite tools: 2D sprite jobs for games: cut sprites out of their background (exact for one-color backgrounds, AI for busy ones), turn animation videos into aligned sprite sheets, make normal maps for 2D lights, build 47-tile autotile sets with Tiled, Godot and Unity rules, slice a sheet into frames, pack frames into an atlas with TexturePacker and Unity metadata, and turn upscaled or AI-generated pixel art into real pixel art on its true grid with a limited palette..

Tool call template

This tool declares no required parameters. Add optional parameters from the input schema as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {},
    "name": "sprite_tools_video_to_sheet"
  }
}

Input Schema

Name	Required	Description	Default
`end`	No
`fps`	No
`start`	No
`video`	No	Base64 MP4, WebM, MOV or GIF.
`columns`	No
`pixelArt`	No	Scale with nearest neighbour.
`videoUrl`	No
`frameSize`	No	Longest side of one frame.
`maxFrames`	No
`background`	No	auto: keep the video's own transparency, key a one-color background, or use AI (max 24 frames).	auto

Schema Changelog

Changes observed during successful MCP inspections.

AddedOct 20, 2026

TDQS

A3.7/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and does well: it discloses billing behavior ($0.15 USDC via x402, charged only on success), the produced artifacts, and processing guarantees (background removed, frames aligned to one box/pivot to avoid jitter, best loop point). It omits failure/limit behavior, e.g. the AI-background frame cap, which would complete the picture.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The first sentence is well front-loaded with the core purpose and deliverables, but the second 'Part of Sprite tools' paragraph is generic catalog boilerplate enumerating every sibling tool, most of which is irrelevant to calling this specific tool and bloats the definition.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a 10-parameter processing tool with no output schema, the description covers the important non-schema ground: the return artifacts, the alignment/pivot guarantee, and pricing. It stops short of documenting input methods (base64 vs URL) and operational limits, which a fully complete definition would include.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is only 40% across 10 parameters, so the description must compensate. It adds semantics for fps and background removal and hints at frameSize via 'one box', but leaves start, end, maxFrames, columns, pixelArt and the video vs videoUrl input distinction entirely unexplained in prose.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The opening states a specific transformation verb (turn) and resource pair (animation video/GIF into a sprite sheet), then enumerates concrete outputs (TexturePacker JSON, Godot SpriteFrames, GIF preview). An agent can immediately tell this is the video-to-sheet pipeline rather than a sibling like sprite_tools_slice or sprite_tools_pack.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It makes clear this tool is for a video/GIF input (from Kling, Veo, Sora or a capture), which implies usage, but never states when to prefer it over the sibling steps it bundles (remove_bg, pack, slice) or when a still-image path would be better. The trailing catalog lists siblings without giving routing conditions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

All Rengi Forge tools Inspect

Try in Browser

Claude Code, inside the Godot 4 editorFlockbay puts an AI agent in the real Godot 4 editor: it writes GDScript, runs your game and fixes what breaks. Free, or bring your own Claude Code or Codex.flockbay.comAd

Glama MCP Gateway

Add one secure layer between your agents and this server.

Resources

Need Help?