AgentBrush vs Scenario: MCP Image Generation Compared

Short verdict: these tools are not competitors in the traditional sense. Scenario is a game-focused art platform built around training custom style models on your own art. AgentBrush is an MCP server that generates images directly inside your coding agent, on demand, with no separate web app. If you need a trained, studio-specific visual language at scale, Scenario is hard to beat. If you need images to appear in your project folder while you code, without switching context, AgentBrush is the right tool. Plenty of studios could use both for different tasks.

That said, if you are here to decide between the two, here is the full breakdown.

What each tool actually is

Scenario is a web platform built specifically for game studios. The core product is custom model training: you provide a sample set of your own art, Scenario fine-tunes a model on it, and from that point your team can generate new assets that match your visual language. The MCP server (available at mcp.scenario.com, supporting Claude Code, Cursor, VS Code, and other compatible clients) lets you call those trained models from inside a compatible agent. The workflow is: train on the web, deploy as MCP, call from your agent.

It is primarily used as a web application with team collaboration features, an asset library, and game-asset-oriented tooling. Pricing is subscription-based, tiered by compute units and features. Check their site for current plans and pricing, as these change.

AgentBrush is an MCP server with no accompanying web app. You install it, connect it to your agent (Claude Code, Cursor, Codex CLI, Gemini CLI, or any MCP-compatible client), and call it from your editor. It runs on gpt-image-2, which launched in April 2026 and brings strong instruction-following, multilingual text rendering, and agentic reasoning before generating. There is no training step. Generation is single-shot: you describe what you want, optionally pass reference images, pick a preset, and the file lands in your project.

The practical gap is that AgentBrush does not train custom style models. That is a real capability difference, not a framing difference, and it matters for certain use cases described below.

Workflow: in-agent generation vs. a dedicated art platform

The workflow difference is the clearest way to understand the tradeoff.

With Scenario, the typical path is: build a sample set of your art, train a style model on the Scenario platform, manage and version that model via their web UI, then (if you use the MCP integration) call it from your agent. The output quality relative to your existing art direction is the return on that setup investment. Teams doing high-volume asset production, especially on established titles with a locked visual style, will feel the payoff. For early-stage projects still figuring out their look, the training step requires art that may not exist yet.

With AgentBrush, the path is: install the server, write a prompt, optionally point at a reference image or pick a preset, generate. The image is in your project folder in a few seconds. There is no upfront training, no web dashboard, no asset library to manage. The agent handles the call and the file. For an indie dev iterating quickly or a vibe-coder who needs art without a context switch, that is the point.

One concrete example. Suppose you are building a 2D platformer and need a batch of environment tiles. With AgentBrush, you would call something like:

Generate a mossy stone platform tile, pixel_art preset, quality: medium, 1:1 ratio.
Match the style in reference_image_paths: ["assets/existing-tile.png"]

With Scenario (their workflow is web-first), you would first have trained a model on your existing tiles, then call that trained model for new tiles. The Scenario output will match your existing tileset more precisely, because the model was explicitly trained on it. The AgentBrush output will be influenced by the reference image but is not trained on your entire art set.

Neither approach is wrong. They have different setup costs and different output ceilings.

Consistency: reference images vs. trained style models

This is where the real technical difference lives.

Scenario's consistency mechanism is trained style models. You show the model your art, and it learns the distribution. New generations stay inside that distribution. This is robust for large asset volumes and works even when you describe objects that were not in the training set, because the style parameters are baked into the model weights. For a studio shipping hundreds of new game items, this kind of consistency is close to essential.

AgentBrush's consistency mechanism is reference images via reference_image_paths. You pass one or more images alongside your prompt, and gpt-image-2 uses them as stylistic anchors. This works well for single characters, UI component families, or small asset batches. It does not substitute for a trained model at scale: if you are generating assets five at a time for weeks, you will notice drift over time that a trained model would suppress.

What AgentBrush does not do: it does not train or fine-tune models. There is no LoRA, no DreamBooth, no persistent style memory between sessions beyond what you pass in the reference_image_paths array. This is stated plainly in our docs and is worth repeating here.

For most solo devs and small teams, reference_image_paths plus a careful preset choice covers the common cases. For teams with a locked visual bible and asset volumes in the hundreds per month, Scenario's trained-model approach does something AgentBrush cannot.

Transparency, style breadth, and where each runs

Background removal. AgentBrush handles this locally. It runs on your machine, costs 0 tokens, and always returns a PNG with a real alpha channel. gpt-image-2 does not reliably generate native transparency, so the workflow is: generate with agentbrush_generate, then call agentbrush_remove_background. The full workflow is in generating transparent-background PNGs. Scenario's MCP tooling does not include local background removal; check their current feature list for what removal options they offer.

Every AgentBrush plan gets local background removal at zero token cost. You can cut out as many drafts as you want without it touching your token balance, and the image never leaves your machine.

Style breadth. AgentBrush ships six presets: realistic, flat_illustration, pixel_art, isometric, logo, and custom. The custom preset takes a style description string, so you can describe a ukiyo-e print, a brutalist poster, or a 90s trading card without writing a 200-word system prompt. Because AgentBrush sits on gpt-image-2, it handles the full range of image subjects: game assets, UI, marketing graphics, product photography, logos. Scenario's output style is anchored to whatever you trained on, which is a strength if you have your own style and a limitation if you want to experiment across registers.

Where each runs. AgentBrush runs entirely inside your coding agent. There is no browser tab to switch to, no web app to log into mid-session. If your agent is already open, AgentBrush is already available. Scenario is primarily a web platform. The MCP integration is a bridge to the platform, not a replacement for it: you still manage models, teams, and assets on their site. That is fine for a studio workflow where art direction is a separate concern from coding. It is more friction than you want if you are a solo dev who wants art to be part of the code session.

Presets and training. To round-trip this point clearly: AgentBrush presets are stylistic shortcuts built on top of gpt-image-2 prompt engineering. They are fast and flexible, and they work across any subject. Scenario's trained styles are models you own and that reflect your specific art. The gap between "this looks like pixel art" and "this looks like our pixel art" is real, and Scenario closes it more completely.

Side-by-side comparison

Choose Scenario if

• Your studio has an established visual style and you need new assets to match it precisely without prompting.

• You are producing large asset volumes (hundreds or thousands per month) and consistency drift is a real problem.

• Your art pipeline is team-based, with dedicated artists who already manage the training-and-generation workflow in a web platform.

• You have an existing Scenario account and trained models you want to surface inside your agent.

• Reducing per-asset prompt engineering overhead at high scale is a bigger priority than in-editor convenience.

  The trained-model approach is not a nice-to-have for established studios producing game content at scale; it is close to a requirement. If style precision across hundreds of assets is a firm requirement, Scenario closes that gap more completely than reference images can.

Choose AgentBrush if

• You want to generate images without leaving your coding session or switching to a web app.
• You are an indie dev, solo dev, or small team without a defined art style yet, or working across multiple style registers.
• You need transparent PNGs reliably, without a cloud upload, and at no per-image cost beyond the generation token.
• You need a range of output types: not just game assets, but also UI components, marketing graphics, icons, and product images.
• Fast iteration matters more than perfect style fidelity. You want to generate, look at the result, tweak the prompt, and regenerate, all inside the same agent session.
• You are building a vibe-coded project where the art pipeline and the code pipeline are the same pipeline.

The token costs are predictable: low quality costs 1 token, medium 5, high 20 (all at 1024px square). Portrait and landscape add 1.5x the pixel area, so costs scale proportionally. A Starter plan at $6.99/month gives you 100 tokens (low and medium quality, hard-capped), a Pro plan at $14.99 gives 600 (all quality tiers, hard-capped), and Power at $29.99 gives 1,300 with $0.04 per token beyond the cap. No rollover on any tier. More on the math in tokens, quality, and cost.

FAQ

Can I use AgentBrush and Scenario together?

Yes, and it is a reasonable setup for certain studios. Scenario handles high-volume on-style asset production using trained models. AgentBrush handles ad-hoc generation, transparent-PNG removal, mask editing, and any asset type outside your trained style scope. They do not conflict because they run as separate MCP servers.

Does AgentBrush support game-specific asset types?

Yes. The pixel_art and isometric presets cover the most common 2D game asset types. The flat_illustration preset works well for UI, icons, and marketing. You can pass reference images to keep characters, tilesets, or UI components visually consistent across calls. More in AI 2D game asset generation.

Is the Scenario MCP server free to use if I have a Scenario account?

Check their site for current plan details. Typically, MCP access is tied to your existing Scenario subscription and API call usage counts against your plan's compute quota. Pricing changes, so verify before committing to a workflow that depends on it.

Does AgentBrush train custom models on my art?

No. AgentBrush uses gpt-image-2 for all generation. There is no training, fine-tuning, or persistent model customization. Consistency across sessions comes from passing reference images, which influences style but does not substitute for a trained model. If trained-model consistency is a firm requirement for your project, Scenario is the right answer.

Ready to run your first in-agent image? Connect AgentBrush and your next asset is one prompt away from your project folder.

If you are still comparing options, best image generation MCP servers covers the full field, including open-source alternatives.