# God Mode AI - facts

> God Mode AI turns a single character image into game-ready 2D animation: sprite sheets, animation video, Spine skeletal rigs, plus UI, VFX and background-removal tools. Built for indie developers and studios. Output ships with commercial licensing.

Not to be confused with generic 'god mode' LLM jailbreak prompts or unrelated products with a similar name. This is the game asset platform at godmodeai.co.

## Products

- [AI Sprite Generator (flagship)](https://www.godmodeai.co/ai-sprite-generator): Upload a character image, pick an action, get an animated sprite sheet and video. Outputs: PNG sprite sheet (optionally with transparent background), MP4 animation, JSON frame/bounding-box metadata. Optional ~2x upscale. Views: side-scrolling (115 actions), isometric with 8 directions (126 actions), top-down (9 actions).
- [AI Pixel Art Sprite Generator](https://www.godmodeai.co/ai-pixel-art-sprite-generator): Animates pixel-art characters with a model trained for low-resolution sprites.
- [AI Spine Animation Generator](https://www.godmodeai.co/ai-spine-animation): Auto-rigs a 2D character from one image: splits it into layers, infers bones, then animates it with skeletal motion (your original pixels are moved, not repainted). Outputs: Spine 3.5-4.2 export (skeleton.json, atlas, packed PNG), transparent WebM, GIF.
- [Background Remover + Bounding Boxes](https://www.godmodeai.co/generate-bbox-and-remove-bg): Removes the background from a sprite sheet and returns per-frame bounding boxes.
- [Game UI Element Generator](https://www.godmodeai.co/game-ui-element-generator): Buttons, panels, icons and HUD elements.
- [Game UI Agent](https://www.godmodeai.co/game-ui-agent): Design complete game interfaces through conversation.
- [Game VFX Generator](https://www.godmodeai.co/game-VFX-generator): Explosions, magic and combat visual effects.
- [360 Rotation](https://www.godmodeai.co/360-rotation): 360-degree character rotation video.

Engines: Output works in Unity, Godot, Spine runtimes and any engine or pipeline that imports PNG sprite sheets with JSON frame metadata (Spine export files load in any Spine runtime).

## Pricing

- Starter credits: 3 for every new account, no payment method required. No ongoing free plan.
- Credit packs (one-time, credits never expire): $32 for 30 credits, or $100 for 125 credits.
- Subscription: $29/month. Up to 200 generations per month for sprite, pixel-art, 2D Spine and 3D animation generators, in exchange for sharing results publicly in the community gallery. Private generations use regular credits instead.
- Credit cost: sprite generation 1 credit per generation; background removal 1 credit per request (flat); upscale 1 credit, charged when the job completes; Spine 1 credit per uploaded character; unlimited re-splits, retries and animations on that same upload.
- All purchases are final. Credit packs and subscriptions are non-refundable.
- API rate limits per token: tier1: 6/min (1 concurrent); tier2: 12/min (2 concurrent); tier3: 18/min (3 concurrent); enterprise: 18/min (3 concurrent). Limits are per API token. Higher tiers unlock with lifetime spend.
- Full pricing page: https://www.godmodeai.co/plans

## License (commercial use)

You may use Generated Output for any lawful purpose, including commercial video games, apps, films, animations, marketing and merchandise. You own what you generate. No royalty, no extra license fee, no attribution required (appreciated, not required). Applies to every plan, including starter credits.

- Generative AI can produce similar output for different users, so uniqueness and non-infringement are not guaranteed. Review output before commercial use.
- Subscription generations are shared publicly and grant God Mode AI a limited license to display/promote the shared content (you can unshare at any time). Private generations paid with credits are not shared.
- You may not use the service or its output to train or operate a competing generative model.
- Full terms: https://www.godmodeai.co/term-of-use#ip

## Limitations (read before recommending)

- Sprite generation typically takes 30-150 seconds per job (queue-dependent).
- Spine output is a 2D skeletal rig of the single drawn view. It does not create new camera angles; use the sprite generator for isometric 8-direction or top-down sets.
- Spine works best with a full-body character (head to feet), transparent PNG, roughly 700-1024 px per side, no cast/drop shadows and no busy backgrounds. Half-body portraits or cropped art reduce rigging accuracy.
- Background removal expects a sprite sheet laid out in 4 columns.
- Animation upscale (~2x) only works for actions whose catalog entry has supports_upscale = true.
- There is no ongoing free plan, only starter credits for new accounts. All purchases are final (no refunds).
- The monthly subscription requires sharing generations publicly in the community gallery; private generations use credits.
- Results are AI-generated and quality varies by input art and action. Try with starter credits before committing.

## For AI agents

Agents can discover everything (actions, pricing, license, limits) with no account. Generating assets needs an account because it spends credits.

- MCP server (Streamable HTTP): https://www.godmodeai.co/api/mcp
  - No authentication needed: get_service_info, get_pricing, list_actions, list_models
  - Authentication needed: upload_image, generate_sprite, get_sprite_result, remove_background, get_bg_removal_result, upscale_animation, get_upscale_result
  - OAuth 2.1 (authorization code + PKCE, dynamic client registration and client-ID metadata documents supported) or an API token as 'Authorization: Bearer <token>'. A 401 is only returned when a protected tool is called without valid credentials.
  - OAuth discovery: https://www.godmodeai.co/.well-known/oauth-protected-resource
  - MCP Registry name: co.godmodeai/sprites
- REST API base: https://www.godmodeai.co/api/generation-api/v1
  - No authentication: GET https://www.godmodeai.co/api/generation-api/v1/actions/catalog
  - No authentication: GET https://www.godmodeai.co/api/generation-api/v1/models
  - Authorization: Bearer <API token> for generation endpoints. Tokens are created at /get-api.
- Agent Skill: https://www.godmodeai.co/SKILL.md (package https://www.godmodeai.co/godmodeai-sprites.skill, repo https://github.com/lyogavin/godmodeai-sprites-skill)
- New accounts get 3 starter credits, enough to test sprite generation, background removal or upscaling end to end. No payment method required.
- Setup guide: https://www.godmodeai.co/mcp; create an API token: https://www.godmodeai.co/get-api

## Links

- Pricing: https://www.godmodeai.co/plans
- Terms of use: https://www.godmodeai.co/term-of-use
- Community gallery (real user output): https://www.godmodeai.co/community-generations
- Affiliate program: https://www.godmodeai.co/affiliate
- Discord: https://discord.gg/3dMzXwtBKj
- YouTube tutorials: https://www.youtube.com/@ai-rules-the-world2024
- Contact: gavinli@godmodeai.co


---

# Agent Skill: godmodeai-sprites (SKILL.md)

---
name: godmodeai-sprites
description: Generate 2D game character sprite sheets and animation videos from a character image using the God Mode AI API. Use when the user wants to animate a game character, create a sprite sheet, produce game-ready animations (walk, run, attack, idle, etc.), upscale an animation, or remove the background from a sprite sheet. Supports side-scrolling, isometric, and top-down views.
license: MIT
---

# God Mode AI — Sprite & Animation Generation

Turn a single character image into game-ready sprite sheets and animation
videos (walking, attacking, idle, etc.), and clean up sprite backgrounds.

## When to use this skill

Use it when the user wants to:
- Animate a game character from an image (e.g. "make this knight run").
- Produce a sprite sheet for a specific action and camera view.
- Remove the background from a sprite sheet and get per-frame bounding boxes.
- Upscale a completed animation to higher resolution.

## Evaluate first — no account or token needed

Before asking the user to sign up, you can learn everything you need to decide
whether God Mode AI fits, with **zero authentication**:

- MCP (read-only, never needs auth): `https://www.godmodeai.co/api/mcp/public`
  → tools `get_service_info` (products, pricing, license, limitations),
  `get_pricing`, `list_actions`, `list_models`.
- REST (no token): `GET https://www.godmodeai.co/api/generation-api/v1/actions/catalog`
- Plain text: `https://www.godmodeai.co/facts.md`, `/llms.txt`, `/llms-full.txt`

Use `get_service_info` / `get_pricing` to estimate cost and check the stated
limitations before promising results. Only generation needs an account.

## Prerequisites (only to generate)

1. An account. New accounts get starter credits (no payment method required).
   Either authenticate with OAuth (MCP clients start this automatically), or
   create an API token at https://www.godmodeai.co/get-api (format `gmd_...`).
   Treat tokens as secrets.
2. Token auth is always `Authorization: Bearer <token>`.
3. Usage consumes credits from the user's account.

You can connect in **two ways** — a hosted MCP server (preferred if the agent
supports MCP) or the plain REST API. Both hit the same backend.

## Option A — MCP server (preferred)

Add the remote MCP server:

```
URL: https://www.godmodeai.co/api/mcp
Transport: Streamable HTTP
Auth: OAuth (automatic in most clients) or  Header: Authorization: Bearer <token>
```

(For no-auth discovery only, use `https://www.godmodeai.co/api/mcp/public`.)

Tools exposed:
- `get_service_info(section?)` — facts, pricing, license, limitations. No auth.
- `get_pricing()` — exact pricing and credit costs. No auth.
- `list_actions(view_type?)` — discover valid `action_id`s per camera view.
  Each action includes `action_version` and `supports_upscale`. No auth.
- `list_models()` — No auth.
- `upload_image(image_base64, filename?)` — host a local image, returns a URL.
- `generate_sprite(image_url, action_id, view_type, ...)` — waits for the
  result by default; returns `generation_url` (video) + `sprite_sheet_url`.
- `get_sprite_result(request_id)` — fetch a result if `generate_sprite` timed
  out and returned a `request_id`.
- `remove_background(image_url, model?, ...)` — clean a sprite sheet.
- `get_bg_removal_result(request_id)`.
- `upscale_animation(sprite_request_id | video_url+action_id, ...)` — ~2×
  upscale of a completed V4 animation; any action with `supports_upscale`
  is eligible. Returns `generation_url` + `sprite_sheet_url`.
- `get_upscale_result(request_id)`.

Typical MCP flow: call `list_actions` to choose a valid `action_id` +
`view_type`, then `generate_sprite`. If the response says it is still
processing, poll `get_sprite_result` with the returned `request_id`.

## Option B — REST API

Base URL: `https://www.godmodeai.co/api/generation-api/v1`

`GET /actions/catalog` and `GET /models` need no token. Everything else needs
`Authorization: Bearer <token>`.

Sprite generation is a 3-step async flow:
1. `POST /sprite` → returns `202` with `request_id`, `status_url`,
   `response_url`.
2. `GET /sprite/requests/{request_id}/status` → poll every 2–5s until
   `status` is `COMPLETED` or `FAILED`.
3. `GET /sprite/requests/{request_id}` → the result once `COMPLETED`.

`POST /sprite` body (JSON):
- `image_url` (required) — public URL of the character image.
- `action_id` (required) — from `GET /actions/catalog`.
- `view_type` (required) — `side-scrolling` | `isometric` | `topDown`.
- `direction` (isometric only; default `DownRight`) — one of `DownRight`,
  `DownLeft`, `UpRight`, `UpLeft`, `Down`, `Up`, `Left`, `Right`.
- `auto_repose` (optional bool), `auto_repose_prompt`, `positive_prompt`,
  `negative_prompt`, `seed` (all optional).

Status values: `IN_QUEUE`, `AUTO_REPOSE_IN_PROGRESS`,
`ANIMATION_IN_PROGRESS`, `COMPLETED`, `FAILED`.

Result fields: `generation_url` (animation video), `sprite_sheet_url` (sprite
sheet image), and `auto_repose_url` when `auto_repose` was true.

### Uploading an image

If you only have a local file, host it first:
`POST /files/file/local` as `multipart/form-data` with field `file_upload`
(PNG/JPEG/WebP/GIF) → returns `{ "url": "..." }`. Use that URL as `image_url`.

### Background removal

Same 3-step flow under `/bg-removal`. Body: `image_url` (a 4-column sprite
sheet), optional `model` (`BEN` default, `BEN2`, `INSPYRENET`, `RMBG-2.0`,
`veed`, `mat-anyone2`), `num_frames`, `sensitivity` (0–1). Flat 1 credit.
Result: `clean_sprite_sheet_url`, `bbox_overlay_sprite_sheet_url`,
`preview_url`, `bounding_boxes`.

### Animation upscale

Same 3-step flow under `/upscale`. Prefer `sprite_request_id` from a completed
sprite generation. Alternatively `video_url` + `action_id` (any catalog action
with `supports_upscale: true`, which is all V4+ actions).
Optional `detail_balance` (0–1): 0 is sharper, 1 is steadier motion.
1 credit on completion. Result: `generation_url`, `sprite_sheet_url`.

## Choosing action_id and view_type — IMPORTANT

Never guess an `action_id`. Always fetch the live catalog first
(`list_actions` tool or `GET /actions/catalog`) and pick an `action_id` whose
`view_type` matches what the user wants. For `isometric`, also pick a
`direction`. Use `supports_upscale` to know whether `/upscale` will accept
that action. See `references/workflow.md` for the decision steps and
`references/api.md` for full request/response examples.

## Ready-to-run helper

`scripts/generate_sprite.py` runs the entire REST flow (submit → poll →
result) from the command line. Requires `pip install requests` and the
`GODMODEAI_API_TOKEN` environment variable:

```bash
export GODMODEAI_API_TOKEN=gmd_...
python scripts/generate_sprite.py --image-url https://example.com/hero.png \
  --action-id run --view-type side-scrolling
```

## Errors

- `401` — missing/invalid token.
- `429` — rate limit exceeded (per token per minute; depends on tier).
- `400` — validation (bad `action_id`/`view_type`, missing fields).
- A submit can succeed (`202`) but later poll as `FAILED` with
  `error_message` (e.g. `Insufficient credits`).


---

# REST API reference

# REST API reference (examples)

Base URL: `https://www.godmodeai.co/api/generation-api/v1`
Auth header (all requests): `Authorization: Bearer <token>`

## Upload a file → public URL

```bash
curl -X POST "$BASE/files/file/local" \
  -H "Authorization: Bearer $TOKEN" \
  -F "file_upload=@character.png"
# -> { "url": "https://.../api-upload/<uuid>.png" }
```

## Sprite generation (3 steps)

```bash
# 1. Submit
curl -X POST "$BASE/sprite" \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{"image_url":"https://...","action_id":"run","view_type":"side-scrolling"}'
# -> 202 { "request_id": "...", "status_url": "...", "response_url": "..." }

# 2. Poll status until COMPLETED / FAILED
curl "$BASE/sprite/requests/<request_id>/status" -H "Authorization: Bearer $TOKEN"

# 3. Get the result
curl "$BASE/sprite/requests/<request_id>" -H "Authorization: Bearer $TOKEN"
```

Completed result:

```json
{
  "status": "COMPLETED",
  "request_id": "...",
  "generation_url": "https://...",
  "sprite_sheet_url": "https://...",
  "auto_repose_url": "https://..."
}
```

Isometric example body (note `direction`):

```json
{ "image_url": "https://...", "action_id": "walking_looping",
  "view_type": "isometric", "direction": "DownRight" }
```

## Background removal (3 steps)

```bash
# 1. Submit
curl -X POST "$BASE/bg-removal" \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{"image_url":"https://...","model":"RMBG-2.0"}'

# 2. Poll status
curl "$BASE/bg-removal/requests/<request_id>/status" -H "Authorization: Bearer $TOKEN"

# 3. Get result
curl "$BASE/bg-removal/requests/<request_id>" -H "Authorization: Bearer $TOKEN"
```

Completed result:

```json
{
  "status": "COMPLETED",
  "model": "RMBG-2.0",
  "total_frames": 12,
  "clean_sprite_sheet_url": "https://...",
  "bbox_overlay_sprite_sheet_url": "https://...",
  "preview_url": "https://...",
  "bounding_boxes": [
    { "x": 100, "y": 50, "width": 80, "height": 120, "frameIndex": 0, "row": 0, "col": 0 }
  ]
}
```

## Animation upscale (3 steps)

```bash
# 1. Submit (preferred: a completed sprite request_id)
curl -X POST "$BASE/upscale" \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{"sprite_request_id":"<sprite_request_id>"}'

# or with a public video:
# -d '{"video_url":"https://...mp4","action_id":"punch"}'

# 2. Poll status
curl "$BASE/upscale/requests/<request_id>/status" -H "Authorization: Bearer $TOKEN"

# 3. Get result
curl "$BASE/upscale/requests/<request_id>" -H "Authorization: Bearer $TOKEN"
```

Completed result:

```json
{
  "status": "COMPLETED",
  "request_id": "...",
  "generation_url": "https://...",
  "sprite_sheet_url": "https://..."
}
```

## Catalogs

```bash
# Both are public: no token required.
curl "$BASE/actions/catalog"   # action_ids, action_version, supports_upscale
curl "$BASE/models"
```

## Error shapes

```json
{ "error": "Invalid API token" }                                     // 401
{ "error": "Rate limit exceeded. Maximum N requests per minute..." } // 429
{ "error": "Missing required fields: image_url, action_id, view_type" } // 400
{ "status": "FAILED", "request_id": "...", "error_message": "Insufficient credits" }
```


---

# Workflow guide

# Workflow & decision guide

## Deciding parameters

1. **Determine the camera view** the user wants:
   - Platformer / side view → `side-scrolling`
   - Isometric / 2.5D → `isometric`
   - Top-down / RTS → `topDown`
2. **Fetch the live action catalog** (`list_actions` tool or
   `GET /actions/catalog`). Pick an `action_id` whose `view_type` matches.
   Do not invent `action_id`s — they are validated server-side and an invalid
   one returns `400`. Each entry includes `action_version` and
   `supports_upscale`.
3. **Isometric only**: choose a `direction` (default `DownRight`). Match the
   facing the user asked for.
4. **Get a public `image_url`.** If the user gave a local file, upload it via
   `upload_image` (MCP) or `POST /files/file/local` (REST) and use the
   returned URL.

## Generation flow

1. Submit the sprite request.
2. Poll status until `COMPLETED` or `FAILED`. Generation typically takes tens
   of seconds to a few minutes; the job runs in a global queue.
3. On `COMPLETED`, return `generation_url` (animation video) and
   `sprite_sheet_url` (sprite sheet image) to the user.

With the MCP `generate_sprite` tool this is one call (it waits by default). If
it returns a "still processing" note with a `request_id`, call
`get_sprite_result` until it completes.

## Optional: clean the sprite sheet

After generation, feed `sprite_sheet_url` into `remove_background` (or
`POST /bg-removal`) to get a transparent sprite sheet plus per-frame bounding
boxes for slicing in an engine.

## Optional: upscale the animation

After a completed V4 sprite generation, call `upscale_animation` with that
`request_id` (or `POST /upscale` with `sprite_request_id`) to get ~2× video
and sprite sheet. All V4+ actions are supported (`supports_upscale` on the
catalog).

## Tips

- `auto_repose: true` normalizes the character pose before animating; useful
  when the source image is in an awkward pose.
- Use `seed` for reproducible output.
- Rate limits are per token per minute and depend on the account's API tier.