New: Artifact-first MCP workflow

Let your coding agent generate, extract, search, and ship game assets.

This is more than installable MCP plumbing. It is a game-dev workflow: agents can generate a mockup or upload a source image, turn it into a project-scoped background or labeled asset pack, inspect linked normalized atlases, upload references, fork from real frames, trace lineage, and return engine-friendly metadata instead of vague suggestions. New accounts get 3 free generations to test the workflow before committing to a bigger pipeline.

This guide is public. Signing in is only required when you want to create a handoff link or let an agent access your private library and generations.

OAuth-firstAPI key fallbackGodot-biased runtime hintsFork and lineage aware

What Agents Actually Get

Search public and private assets by style, quality, review state, project, visibility, date, and lineage.

Generate a mockup or upload a loose source image, then transform it into a labeled asset pack, character sheet, or background while keeping lineage back to the source artifact.

Poll long-running jobs, inspect previews, and open linked durable packs without leaving the agent workflow.

Use normalized atlases, enhanced sheets, signed sheet URLs, and Godot-biased runtime hints for engine handoff.

Fork from a frame, create a variation, or upload fresh reference art and generate from that with app-form controls.

Read full lineage trees and placeholder guidance so the agent knows what is original, derived, or reusable before generating.

Why this matters

Agents stop improvising their own asset pipeline.

The MCP now tells them how to go from rough source image to labeled pack, when a result is a fork, how to branch from it without losing lineage, and what to ship to the engine.

What Your Agent Can Actually Do

Not just install the server. Use it like part of a real production workflow.

Start from a mockup, screenshot, or concept image

Agents can generate a fresh mockup or source image, or upload an existing concept image, screenshot, or paintover as a project artifact before deciding what to extract from it.

Turn one source image into reusable outputs

From that one artifact, agents can extract a clean background, a character sheet, or a labeled asset pack that stays linked back to the original source and any resulting durable pack.

Pull atlas-ready sheets instead of random previews

Responses expose normalized and enhanced sheet assets, signed sheet URLs, rows, columns, frame counts, cell sizes, and runtime guidance so the agent can hand your engine a real spritesheet.

Search the right slice of your library

Agents can search public assets, your private library, or one project at a time with filters for style, category, review state, recency, quality, visibility, and lineage before they generate anything new.

Upload references or source images

Agents can import remote images or local-file data URLs either as reusable references for generation or as project artifacts for later extraction and reuse.

Poll jobs and inspect intermediates

Long-running generations and transforms return run ids, artifact ids, preview handles, and linked durable packs so the agent can see where a job is in the pipeline instead of guessing.

Fork from a specific frame

Frame-backed forks preserve parent sheet, parent frame, fork type, and prompt context. That means agents can extend a real character instead of starting over.

Trace full lineage, not just direct parents

Lineage reads return graph-shaped fork trees with roots, descendants, branch points, and similar generations kept separate from true parent-child relationships.

Recommended Game Workflow

Source

Generate or upload a source

Start with a fresh mockup, source image, concept frame, or screenshot. The artifact layer keeps that source project-scoped before you commit to any durable pack.

Transform

Extract what matters

Transform that artifact into a labeled asset pack, a background, or a character sheet. The MCP nudges agents toward clean cutout sheets instead of decorative presentation boards.

Track

Poll and inspect

Use run status and artifact reads to inspect progress, previews, and linked packs while long-running jobs finish.

Find a placeholder fast

Search public sheets first, filter for reviewed or recent assets, and inspect the normalized sheet before the agent decides to generate anything new.

Fork

Branch from what already works

When a private frame is already close, the agent can fork that exact frame and preserve lineage instead of inventing a new identity from scratch.

Guide

Lock style without losing control

Upload style boards or concept art, then combine them with a frame-backed subject reference so consistency and flexibility stay separate.

Ship

Hand off runtime-ready output

Use the normalized atlas plus rows, cols, frameCount, and cell size to wire the result straight into Godot, Unity, or your own importer.

The Tool Map

If you are steering an agent, this is the practical mental model.

Tool

Use It When

What Comes Back

generate_artifact

Start from scratch when you need a mockup, screen concept, scene image, or source art before extraction.

Creates a project-scoped generated artifact, stores the generation plan and run metadata, and points the agent toward transform_artifact as the next step.

list_project_artifacts

Inspect generated mockups, loose source images, extracted backgrounds, and in-progress asset packs inside one project.

Returns artifact status, preview handles, lineage pointers, and any linked durable spritesheet group.

get_artifact

Open one artifact in detail after generation or transformation starts.

Returns artifact metadata, status, preview resources, any linked durable pack, and workflow hints about which tool to call next.

upload_artifact_image

Start from a mockup, concept image, screenshot, or existing source art.

Creates a project-scoped artifact that can later be transformed into a background, character sheet, or labeled asset pack.

transform_artifact

Turn one generated or uploaded artifact into extracted assets, characters, or a clean background with guidance.

Starts a transform job and eventually links the artifact to a durable extracted pack/spritesheet when the operation produces multiple usable sprites.

get_run_status

Poll a long-running transform or generation job without guessing which record owns it.

Returns live Trigger.dev status, related artifact or spritesheet context, and any available output or error details.

list_projects

Choose the right destination before the agent generates anything new.

Returns only the authenticated user's projects so generation stays inside a real workspace.

search_spritesheets

Find placeholders, recent private work, reviewed assets, or one fork family.

Returns atlas metadata, asset variants, preview links, and forkInfo for fast triage.

get_spritesheet

Open one promising result in detail.

Returns frames, normalized and enhanced sheet assets, gameIntegration metadata, and lineage hints.

get_frame

Inspect one frame or grab a frame-backed subject reference.

Returns frame metadata, preview links, and provenance data.

upload_reference_image

Bring in turnarounds, sketches, mood boards, or concept art.

Stores a reusable reference asset and returns the exact value to drop into referenceImages.

fork_frame

Make a new branch from one source frame.

Creates a lineage-preserving fork that can inherit kit membership and keep identity anchored.

generate_variation

Ask for another take of an existing sheet.

Creates a variation child under the parent spritesheet without making the agent rebuild the prompt flow.

generate_spritesheet

Generate from text plus structured style, subject, and inspiration references.

Starts generation and echoes the reference strategy so the agent knows what was actually applied.

get_generation_status

Poll until the new atlas is ready.

Returns ready state, normalized assets, runtime hints, and the metadata resource for the finished sheet.

get_lineage

Understand how a sheet relates to parents, descendants, and siblings.

Returns nodes, edges, partial-access hints, rootGroupId, and optional similar generations.

find_or_generate_placeholder

Give the model a workflow that searches public sheets first and only generates last.

Returns a reusable MCP prompt that points agents toward placeholder reuse, normalized atlases, and structured references.

Designed To Be Machine-Friendly

Why agents move faster here

Private assets stay account-gated through the same auth model as the app.

Project artifacts, extracted packs, atlas dimensions, and frame counts are explicit instead of implied.

Fork lineage is a first-class concept, not a hidden side effect of references.

Runtime hints default toward Godot, but the asset metadata is engine-agnostic enough for custom pipelines too.

Artifact transform result

{
  "id": "artifact-uuid",
  "status": "processing",
  "kind": "asset_pack",
  "linkedGroupId": "group-uuid",
  "previewUrlResourceUri": "asm://artifacts/artifact-uuid/preview-url",
  "nextSuggestedTools": ["get_run_status", "get_artifact", "get_spritesheet"]
}

Atlas-ready metadata

{
  "assets": {
    "normalizedSheet": { "kind": "normalized_sheet" },
    "enhancedSheet": { "kind": "enhanced_sheet" }
  },
  "gameIntegration": {
    "recommendedWorkflow": "atlas",
    "rows": 3,
    "cols": 3,
    "frameCount": 9,
    "cellWidth": 512,
    "cellHeight": 512
  }
}

Run-status polling

{
  "runId": "run_123",
  "status": "EXECUTING",
  "artifactId": "artifact-uuid",
  "artifactStatus": "processing",
  "relatedGroupId": "group-uuid"
}

Agent workflow, not just agent install

Give your coding agent a real sprite pipeline.

Start from source art, extract what matters, search before you pay, and only generate new sheets when the agent actually needs them.

Artifact-aware reads

Project-scoped source images, linked transformed outputs, signed artifact previews, and durable extracted packs.

Lineage-aware writes

Frame forks, sheet variations, structured subject references, and graph reads.

Game-ready outputs

Normalized atlases, frame metadata, runtime hints, and outputs that can start as mockups and end as reusable runtime packs.

Common Questions

What can an agent do with the AI Spritesheet Maker MCP?

An authenticated agent can search public and private spritesheets, inspect atlas metadata and frames, generate project-scoped mockups or source images, upload existing concept art, transform artifacts into extracted backgrounds, character sheets, or labeled asset packs, poll long-running jobs, upload reusable reference images, fork from a specific frame, create variations, generate new spritesheets, and trace lineage across a fork family.

Does this work for real game development workflows?

Yes. The MCP supports the whole flow from rough mockup or source image to reusable asset pack to runtime atlas. It returns normalized sheet assets, rows, columns, frame counts, cell sizes, and runtime hints so agents can hand off engine-ready atlases instead of one-off previews.

Can agents preserve character identity instead of regenerating from scratch?

Yes. Agents can fork directly from a frame or use a subject reference with frame provenance, which preserves lineage and makes derivative work traceable.

Which coding agents or editors is this designed for?

The workflow is built for coding-agent environments like Codex CLI, Claude Code, Cursor, and similar MCP-capable tools, with OAuth-first install flow and API key fallback when needed.