Game assets with FixedSeed

FixedSeed runs image, video, 3D, audio and language models behind one API key and one prepaid wallet. Use it whenever the mod needs something that doesn't exist yet: a weapon sprite, a boss, a unit rendered from 16 angles, a tileable floor, a laser sound, boss music, a voiced line.

Setup (check once per session)

• Key. FIXEDSEED_KEY must be set (create one at https://fixedseed.com/developers/keys and top up the API wallet at https://fixedseed.com/developers/billing). fsgc fixedseed also reads it from a .env file (FIXEDSEED_KEY=...) in the working folder. Never write the key into mod files; fsgc publish check flags leaked keys. fsgc fixedseed balance shows the wallet.
• A key for the agent. Suggest the user gives the agent its own key with a spend limit (monthly or lifetime, set when creating the key at https://fixedseed.com/developers/keys). The API stops that key at its limit whatever the agent does, so a runaway loop can't drain the wallet.

• MCP. The FixedSeed MCP server ships with this repo: fsgc fixedseed mcp (stdio, stdlib only). It reads FIXEDSEED_KEY (and optionally FIXEDSEED_API, default https://run.fixedseed.com) from the environment. It's pre-configured for each agent:

  • Claude Code: .mcp.json
  • Codex: .codex/config.toml
  • Cursor: .cursor/mcp.json
  • VS Code/Copilot: .vscode/mcp.json
  • Gemini CLI: gemini-extension.json

  To add it by hand:

  • Claude Code: claude mcp add fixedseed -e FIXEDSEED_KEY=$FIXEDSEED_KEY -- /path/to/repo/bin/fsgc fixedseed mcp
  • Codex (~/.codex/config.toml): [mcp_servers.fixedseed] with command = "/path/to/repo/bin/fsgc", args = ["fixedseed", "mcp"] and env_vars = ["FIXEDSEED_KEY"]
  • anything else: a stdio server whose command is bin/fsgc fixedseed mcp.

  MCP tools: search_models, get_model (input schema, example, price), upload_file, estimate (what a plan costs), generate (queue, wait, download into out_dir, manifest line, previews), generate_batch (many at once under a max_cents cap), get_request (finish a long job), get_balance. The same server has a passthrough tool and prompt for running two games at once (see the mashup-mods skill).

• Plain HTTP works too: https://run.fixedseed.com/v1/llms.txt documents every endpoint and model with current prices, and /v1/openapi.yaml is the contract.

Which interface

• Discovery (which model for X, its inputs, its price): MCP search_models / get_model, or fsgc fixedseed search "<words>" [--kind image|video|audio|model], fsgc fixedseed schema <model>, fsgc fixedseed price <model>. The catalog is public and live, so these need no key. The defaults below were current in October 2026; check before a big batch.
• Anything that must land on disk (every game asset): fsgc fixedseed <recipe> or MCP generate. Both upload local inputs through /v1/files, queue, poll, download every output file, and append the model, inputs and request id to <out>/fixedseed_manifest.jsonl, so every asset can be traced and regenerated.
• Long jobs (video, 3D, long music): MCP generate with wait: false (or let it time out) returns a request_id; collect it with get_request or fsgc fixedseed result <request_id>.
• Retries never pay twice: MCP generate and generate_batch (and fsgc fixedseed batch) record every request in <out>/.fixedseed_ledger.jsonl. Asking again for the same model, input and name within an hour (after a timeout, a crash, a dropped connection) collects the earlier request. For a new variation, change the name or pass fresh: true (--fresh). A result never replaces an earlier file.
• Many assets at once (every item of a mod, a set of sounds): MCP generate_batch with max_cents, or fsgc fixedseed batch plan.json --max-cents 300 with a plan of {"model", "input", "name"} jobs. New requests over the cap are refused before anything is spent; whatever is still running comes back as pending, and running the same batch again collects it.
• Limits, and what a refusal costs. An account runs only its plan's number of requests at once, counting every key and the fixedseed.com site. A key can also have a spending limit, and the wallet must cover each request's hold (its maximum charge, settled to the real cost when it finishes). The API checks all three before it holds anything, so a refused request is never charged, and the error names the limit with its numbers: plan, limit and active; or the key's limit, what it has committed and when it resets; or the balance against the model's maximum. Plan around them:
  • Send many assets as one batch, not as parallel generate calls. The batch starts the rest as slots free up.
  • A single generate (or CLI recipe) waits up to about a minute for a slot, then reports the limit.
  • Fit the plan to what the key has left.
• Look at what came back: MCP results carry small previews (sprites enlarged with hard edges, an archive's preview.png, video keyframes, audio waveforms). Check them before building on a result.

Recipes (fsgc fixedseed <recipe> --help for options; fsgc fs is the same; --model overrides the model; --set k=v passes extra inputs)

Results with several files (rigs, PBR sets, motion clips, SVG, alpha video) arrive as one ZIP that fsgc fixedseed and the MCP generate tool unpack into <out>/<name>/, with a manifest.json listing the files.

Other useful models (fsgc fixedseed schema <model> for inputs):

• Images: openai/gpt-image-2.5-flare, google/nano-banana-pro, black-forest-labs/flux-2-pro, qwen/image-edit-max (precise edits), ideogram/v4 (lettering, logos), bytedance/seedream-5-pro.
• Upscale: topaz/bloom-2-image (creative upscale for low-res art), black-forest-labs/flux-image-upscaler.
• Video: bytedance/seedance-2.5-t2v / -r2v (reference-driven shots), minimax/h3-max-i2v, google/veo-3.1, kling/video-v3-pro-motion-control (copy motion from a reference clip), topaz/video-upscale.
• Characters: fixedseed/character-turnaround (6-panel turnaround sheet video from 1-3 refs), fixedseed/character-expressions (expression sheet).
• Audio: deepgram/nova-3 (speech-to-text, e.g. subtitles for a showcase).
• Text: chat models through POST /v1/chat/completions (OpenAI format) for item names, dialogue and lore.

Prompting game art that fits the game

• Look at the game's own assets first: pixel size, outline, palette, perspective, facing, how busy they are. Put that into a reusable style suffix. For Terraria: "16-bit pixel art game sprite in the style of Terraria, crisp dark outline, limited palette, centered, plain flat white background, no shadow, no text".
• Describe the view and orientation explicitly: "perfectly horizontal side view with the muzzle pointing right" for held weapons, "seen from the side facing left" for enemies, "pointing straight down" for a falling bomb. Engines have conventions (Terraria items point right, NPCs face left) and fixing orientation afterwards costs quality.
• Backgrounds: transparent (fsgc fixedseed sprite, GPT Image 2.5 with background=transparent) or a flat colour that fsgc sprite cutout can flood-fill. Avoid gradients, scenery and ground shadows. If a soft shadow sneaks in, use --grey / --keep-top in cutout.
• Player / team colour: ask for "bright saturated blue accents" on the parts that should take the player's colour, then fsgc sprite team-mask --hue blue turns them into a mask.
• Consistency across a set: generate one hero image, then derive the rest with fsgc fixedseed edit and the hero as --ref ("same robot, now firing, muzzle flash"; refer to refs as @Image1, @Image2). Don't ask one prompt for a whole sprite sheet; grids come out uneven.
• Many angles or frames of the same object: go 3D. Take the concept, run fsgc fixedseed model3d, then fsgc render3d from the game's camera (asset-pipeline skill). That's how the AoE2 robotaxi got 16 consistent headings × 5 animations. Generated meshes are dense: fsgc fixedseed remesh --faces 8000 before shipping real-time 3D. For characters, fixedseed/character-turnaround gives matched front/side/back views to model or draw from.
• Pixel art: generate at 1K with a pixel-art prompt, then snap it to the real grid and palette locally with fsgc sprite pixelate / fsgc sprite palette --from <game sprite>; it uses the game's exact frame size.
• No text or logos in art unless wanted: models love to add them.

Rigging and animation

• Humanoids: fsgc fixedseed model3d char.png --engine meshy --set pose=a-pose gives a clean A-pose, then fsgc fixedseed rig char.glb adds a skeleton plus walking and running clips (GLB and FBX); --animate <id> adds a preset from Meshy's animation library (0 = idle).
• Custom moves: fsgc fixedseed motion "<what the character does>" returns an FBX clip on a standard humanoid skeleton; retarget it in Blender or the engine (Unity Humanoid, Unreal IK Retargeter).
• Sprites: fsgc render3d --anims animates rigid parts procedurally, and fsgc sprite frames makes quick idle loops. For video-driven motion, kling/video-v3-pro-motion-control transfers motion from a reference clip.

Audio for engines

• Every audio result is a WAV (ElevenLabs at 44.1/48 kHz, Song at 48 kHz stereo). Convert to what the engine wants:
  • ffmpeg -i x.wav -ar 44100 x_44k.wav (XNA/tModLoader, most engines);
  • ffmpeg -i x.wav -c:a libvorbis -q:a 5 x.ogg (Minecraft, Godot, Unity);
  • trim silence first: -af silenceremove=start_periods=1:start_threshold=-50dB.
• Loops: fsgc fixedseed sfx ... --loop, or ask Song for a loopable track and crossfade the ends.
• Keep SFX short (0.2-2 s) and normalize loudness (-af loudnorm=I=-16) so they sit with the game's own sounds.

Cost and etiquette

• Price the expensive stuff: every model lists starting_charge_cents and maximum_charge_cents (fsgc fixedseed price <model> / MCP get_model). Before 3D, video, long music or any batch, run fsgc fixedseed estimate model[:count] ... (MCP estimate) and tell the user the range; ask before spending more than about $5. Failed requests are not charged.
• Iterate cheap: use low quality or resolution while exploring (--quality low, --res 512 / 1K), then re-run the winners at full quality with the same prompt (and seed where the model takes one).
• Reproducibility: keep fixedseed_manifest.jsonl with the assets; it records prompts, inputs and request ids.
• Credits: in the mod's README, credit that assets were generated with FixedSeed and name the models. Check the model's provider terms for commercial use (https://fixedseed.com/docs).