How to give a coding agent a complete 2D game-art pipeline over MCP

SpriteShip Team — Thu, 20 Aug 2026 12:42:02 +0000

Most coding agents can write the player controller, register an animation, and
load a texture atlas. They usually stop at the point where the art has to exist.

That boundary is awkward for an autonomous workflow. An image generator can
produce a PNG, but the agent still has to guess how to split frames, name
animations, build an atlas, define collision, and package everything for the
engine.

SpriteShip's hosted Model Context Protocol server is meant to close that gap. It
currently exposes 41 tools for creating, reading, revising, animating, and
exporting a game's 2D art layer.

The cover image for this article was AI-generated with SpriteShip.

What the agent can actually make

The tool surface covers more than characters:

animated characters and directional turns;
static props and animated objects;
tilesets, terrain sheets, backgrounds, and seamless textures;
level maps assembled from those assets;
engine-native exports for Phaser, Godot, Unity, GameMaker, and Tiled.

The important part is the sequence. An agent can create a project, generate an
asset inside it, poll the asynchronous job, inspect the result, and export files
without requiring somebody to first prepare the entity in the web dashboard.

Connect the MCP server

Create a scoped API key in SpriteShip under Account → API keys, then expose it
to the process running your agent:

export SPRITESHIP_API_KEY="ss_live_..."

The MCP endpoint is:

https://spriteship.com/mcp

An MCP client configuration has three essential fields:

{
  "mcpServers": {
    "spriteship": {
      "url": "https://spriteship.com/mcp",
      "headers": {
        "Authorization": "Bearer ${env:SPRITESHIP_API_KEY}"
      }
    }
  }
}

The exact config-file location differs between Claude Code, Cursor, Windsurf,
Cline, and Codex, but the endpoint and authorization header are the same.

Start with a project

Characters and assets live inside a project. The project also owns the permanent
game perspective that guides later generations: platformer, angled top-down,
straight overhead, isometric, or point-and-click.

create_project is synchronous and free. A typical instruction to the agent is:

Create a platformer project called Clockwork Harbor. Use a hand-drawn style and
describe it as a foggy port city powered by unreliable brass machinery.

Before creating anything, the agent should call list_projects and reuse a
matching project rather than creating a near-duplicate.

Generate four character options for one image call

create_character makes the initial character image. Setting both gridRows
and gridCols to 2 asks for a four-variation sheet. It is still one image call,
so the four resulting character designs have the same generation cost as one.

That makes the sensible first workflow:

Request a 2×2 set of character variations.
Poll the returned job with get_job.
Show the four characterPreviews to the user.
Animate only the selected design.

Generation is asynchronous. The create call returns a jobId; when the job is
finished, get_job returns the created character IDs and expiring preview URLs.

Preview the cost before spending

Paid SpriteShip MCP tools default to dryRun: true. A dry run returns the
estimated credit cost, current balance, daily spend cap, recent spend, and
remaining cap. It generates nothing.

The expected exchange looks like this:

user: make four plague-doctor character concepts for this project

agent: the generation is estimated at 150 credits. Your balance after the call
       would be 1,350 credits. Shall I run it?

user: yes

Only after that explicit approval should the agent repeat the call with
dryRun: false.

This is backed by server-side controls rather than prompt etiquette:

API keys have separate read, write, and spend scopes;
each key has a daily credit ceiling;
real writes are idempotent, so a retry cannot dispatch and charge twice;
writes against a busy entity are rejected instead of racing;
revoking a key cancels its unfinished jobs.

When a job reaches a terminal state, the agent should report the job's actual
net charge rather than repeating the estimate. Four variations still come from
one charged image call, and failed steps can change the final amount.

Add real motion

The still image and its animations are intentionally separate decisions.
generate_character_animation creates image-to-video motion such as a walk,
idle, attack, or dodge. Each generated animation is a separate paid video call,
so the agent should ask which motions are actually needed.

For directional characters, a generated direction can also produce a free
mirrored copy in the same job. A real second generation is still the right choice
for an asymmetric character, because mirroring moves a held item to the opposite
hand.

Recent animation work also makes the generated motion more usable downstream:

the starting pose is checked for visual inventory so empty hands remain empty and existing held items are preserved;
occupied animation names resolve non-destructively (jump, jump_2, jump_3);
jump animations can be split into takeoff, airborne, and landing phases;
character exports carry ten skeleton-derived attachment points for equipment and effects.

Export something the engine understands

Once the character is ready, get_export_command returns an authenticated URL
and a ready-to-run curl command for the chosen engine. The agent runs that
command in its own shell rather than passing a multi-megabyte zip through the
language model.

An export can contain:

sprite sheets and atlas metadata;
native engine resources;
animation names and frame timing;
collision shapes and ground footprints;
per-frame equipment attachment points;
a manifest, JSON Schema, README, and SpriteShip skill instructions.

That last group matters. The bundle explains its own structure, so the coding
agent can register the animation in the game instead of inventing a file layout.

A useful end-to-end prompt

After connecting the server, try an instruction shaped like this:

Create a platformer project for a clockwork harbor game. Preview the cost of
four character designs for a lantern-carrying mechanic. Wait for my approval
before spending anything. When they finish, show me the options and let me pick
one. Then quote an idle and walk animation, generate only after I approve, and
export the result for Phaser.

That single request exercises the important boundaries: project context, cost
preview, explicit approval, asynchronous jobs, visual selection, separate
animation spend, and engine-native export.

Where to go next

Agent overview and setup guides: https://spriteship.com/agents
MCP endpoint: https://spriteship.com/mcp
API and key management: https://spriteship.com/account/api-keys

SpriteShip includes 1,500 starting credits and does not require a card to try the
first workflow. Reading existing assets and re-exporting them are free; credits
are used for new AI generations.

DEV Community: SpriteShip Team