AI Game Asset Generator: How Nano Banana 2 Helps Studios Cut Concept Art Production Time by 80%

Introduction — Why concept art is the bottleneck in game production

Concept art is often where a game starts and where schedules quietly go to die. A single senior character concept can take 8–40 hours once you include references, sketches, revisions, and approval passes. A full RPG roster can stretch into months before a production team even locks the final direction. That delay affects everything downstream: rigging, modeling, animation tests, UI tone, environmental set dressing, and even marketing plans.

For studios and AI product teams, this is exactly where an AI game asset generator makes sense. The goal is not to replace art direction. The goal is to shrink the time spent exploring options, rejecting off-brief concepts, and redoing work because the style drifted halfway through a sprint. Nano Banana 2, exposed on WisGate as gemini-3.1-flash-image-preview, is useful here because it is built for high-volume iteration, stable output, and practical production use rather than one-off novelty images.

If you are building a tool for game teams, the real question is not whether the model can make a pretty picture. The question is whether it can support a repeatable concept art workflow, produce UI and environment variations, and still stay aligned with a project bible. That is the lens for the rest of this article.

Open AI Studio now and validate your concept art prompts against real game briefs while you read. If you want to test image generation immediately, start at https://wisgate.ai/studio/image and compare drafts against your own art direction notes.

Why Nano Banana 2 Works for AI Game Asset Generation

Nano Banana 2 is a good fit for game asset generation because it is tuned for iterative image work, not just single-shot outputs. On WisGate, the model is exposed as gemini-3.1-flash-image-preview, with pricing at $0.058 per image/request versus the official $0.068 per image/request. That difference matters when you are generating hundreds or thousands of drafts for characters, UI, environment references, and marketing packs. The model also supports consistent 20-second generation across 0.5K to 4K base64 outputs, which makes it easier to plan for batch runs and editor-side previews.

The 256K context window is another production detail that often gets overlooked. In game work, a prompt is rarely just a prompt. It is a project bible, a faction note, a character sheet, a material reference list, a style guide, and a list of exclusions. A larger context window means you can keep more of that art direction in scope when generating across multiple turns. That helps with continuity, especially for studios working on long-form content where consistency matters more than surprise.

The model’s edit performance also matters in practical terms. The source data puts Nano Banana 2 at edit rank #17 with a score of 1,825, while Pro sits at #2 with a score of 2,708. That is a useful signal for routing: Nano Banana 2 is a strong volume and iteration model, while Pro is better reserved for hero assets and final presentation pieces. For game tools, that split is exactly what you want. Draft fast, then escalate only the assets that need premium polish.

Three failure modes that break game asset production

There are three common ways image generation fails in a game pipeline. First is anatomical inconsistency. Characters change face shape, hand count, armor geometry, or pose logic across variations, which creates extra review time and undermines trust in the tool. Second is style drift. A concept sheet may start in the project’s visual language and then wander into a different rendering style after a few revisions. Third is missing real-world reference access. A fantasy city inspired by Byzantine geometry, desert architecture, or Nordic material language needs grounding in actual visual sources or the output can feel generic and unconvincing.

These issues are not cosmetic. They create rework. Rework costs schedule, and schedule costs money. That is why an AI game asset generator has to be evaluated against production constraints, not only visual appeal. Nano Banana 2 is useful because it supports batch generation and multi-turn refinement in a way that fits concept art approval cycles. It gives art directors room to narrow the output without restarting from zero.

Model specs that matter for production workflows

For production planning, the specs that matter are the ones that affect throughput and consistency. The relevant model ID is gemini-3.1-flash-image-preview. The WisGate price is $0.058/request, compared with the official price of $0.068/request. Generation time is 20 seconds. Context is 256K tokens. Resolution options are 0.5K, 1K, 2K, and 4K. The model can also produce extreme aspect ratios, including 1:4, 4:1, 1:8, and 8:1, along with standard ratios such as 1:1, 16:9, 9:16, and 21:9.

That combination matters in a studio setting. Drafts can stay at 2K for fast review, while hero presentation assets can move to 4K. Long, thin output formats are useful for UI bars, banners, posters, loading screens, and social formats. If you are building an AI image generation tool for a game team, these are not edge cases. They are daily production requirements.

Why gemini 3.1 flash architecture changes game asset generation

The architecture behind gemini 3.1 flash changes the workflow because it introduces Image Search Grounding into image generation. For game studios, grounding means the model can reference external visual sources when the brief depends on real-world accuracy. That is important for historical armor, regional architecture, geological formations, industrial materials, and any environment that needs believable reference structure rather than purely invented forms.

Without grounding, the model approximates. With grounding, it can reference. That distinction is especially useful in environment concept art, marketing key art that needs recognizable settings, and any asset that sits close to real-world culture or history. It is less useful when the objective is style-consistent batch generation, such as a roster of fantasy characters where internal consistency matters more than web reference accuracy.

The technical detail to remember is simple: grounding and imageConfig only work on the Gemini-native endpoint. If you are integrating into a pipeline, you need to route grounded jobs through the Gemini-native call path and not assume every endpoint supports the same feature set. That is one of those details that looks small in a spec sheet and becomes a debugging problem in production.

When to enable Image Search Grounding in game workflows

Enable grounding when the art depends on verifiable visual cues. That includes historical factions, architecture inspired by specific regions, military equipment that needs to look plausible, and environments built around known materials or geography. It also helps when a studio needs art directors to compare generated images against established reference packs. In those cases, grounding reduces the amount of hand correction needed later.

Disable grounding when the priority is internal style consistency. If you are generating fifty character variations for a single faction, the team usually wants repeatable visual language, not web-referenced realism. The same logic applies to stylized UI, icon sets, and some marketing compositions. Grounding can introduce unnecessary detail from outside the style bible, and that can slow approval rather than help it.

A useful rule is this: if the brief includes names of places, periods, materials, or real-world objects, consider grounding. If the brief is about a locked fantasy style, suppress it. That decision rule keeps your pipeline predictable.

Gemini-native endpoint constraint for grounding

Grounding is not a generic toggle that works everywhere. For game workflows using WisGate, you need the Gemini-native endpoint to support grounding and imageConfig. That matters if your tool abstracts model selection behind a single UI. The backend still needs to understand which jobs require the native endpoint and which jobs are standard batch generations.

This is where a production-minded integration pays off. If a concept art request needs real-world reference retrieval, route it through the grounded Gemini-native flow. If the request is a high-volume batch of character variations, keep it on the simpler volume path. That separation avoids feature leakage and makes failures easier to diagnose.

Workflow 1 — AI game asset generator for character and creature concept art

Character and creature design is the clearest use case for an AI game asset generator because the work is repetitive, revision-heavy, and expensive when done manually. A studio might need ten versions of a hero, thirty roster characters, or multiple creature families before one direction is approved. A mid-scale RPG example can easily involve 30 characters × 5 variations × 3 angles, which is the kind of workload that turns a concept phase into a bottleneck.

The practical advantage of Nano Banana 2 is batch consistency. You can keep the style bible in the prompt, generate multiple options, and then refine the strongest candidates without restarting the entire process. That is especially useful for studios that need silhouette readability, faction consistency, and a shared visual language across multiple classes or enemy types. The model is not a substitute for art direction. It is a drafting layer that reduces the number of dead-end sketches.

Six-layer prompt framework for character briefs

The most reliable character prompts are structured. Start with role, then physique, then equipment, then style language, then pose, then output spec. That gives the model enough guardrails to stay within the franchise’s visual rules while still producing useful variation. For example, “frontline tank,” “lean heavy-armor build,” “tower shield and broken banner,” “weathered dark-fantasy steel,” “three-quarter stance,” and “2K concept sheet with side profile variations” is a stronger brief than a vague request for a cool warrior.

The key is not verbosity for its own sake. It is controlled specificity. A model does better when the prompt tells it what to preserve and what to vary. In game art, that means anchoring the silhouette, marking the gear language, and defining the output format so the team can compare concepts without reformatting each image by hand.

Batch generation code for character concepts

The following Python example shows a basic batch generator using gemini-3.1-flash-image-preview. It is designed for concept art iteration, where each prompt shares a core art direction but varies role, armor, species, or mood. In a production tool, you would add retries, logging, and asset storage, but this is enough to demonstrate the workflow.

import base64
import requests
from pathlib import Path

API_KEY = "YOUR_WISGATE_API_KEY"
URL = "https://wisgate.ai/v1beta/models/gemini-3.1-flash-image-preview:generateContent"

prompts = [
    "Fantasy ranger, lean build, layered leather armor, bow, forest palette, three-quarter pose, 2K concept sheet",
    "Heavy infantry captain, broad silhouette, plated armor, halberd, scarred helm, front-facing stance, 2K concept sheet",
    "Arcane scholar, ornate robes, rune staff, compact silhouette, calm expression, turnaround-ready concept, 2K concept sheet"
]

headers = {
    "x-goog-api-key": API_KEY,
    "Content-Type": "application/json"
}

for i, prompt in enumerate(prompts, start=1):
    payload = {
        "contents": [{
            "parts": [{"text": prompt}]
        }],
        "generationConfig": {
            "responseModalities": ["TEXT", "IMAGE"],
            "imageConfig": {
                "aspectRatio": "1:1",
                "imageSize": "2K"
            }
        }
    }

    response = requests.post(URL, headers=headers, json=payload, timeout=35)
    response.raise_for_status()
    data = response.json()

    for candidate in data.get("candidates", []):
        content = candidate.get("content", {})
        for part in content.get("parts", []):
            inline = part.get("inlineData")
            if inline and "data" in inline:
                image_bytes = base64.b64decode(inline["data"])
                Path(f"character_concept_{i}.png").write_bytes(image_bytes)
                break

A few implementation details are worth calling out. The timeout is set to 35 seconds, which gives the model room to complete the consistent 20-second generation without making your client brittle. The image size is 2K because draft review rarely needs 4K detail. That keeps iterations fast and reduces the temptation to overwork concepts before the team has even agreed on the direction.

Multi-turn refinement for concept art approval cycles

Multi-turn refinement is where an AI game asset generator starts to feel useful to art direction instead of merely experimental. After the first batch, the director can request narrower shoulders, more angular shoulder plates, a lighter helmet profile, or a different insignia layout. The model can then apply those edits while keeping the core visual language intact. That is much closer to how concept sheets are reviewed in a real studio.

A useful pattern is to treat the first turn as exploration, the second as selection, and the third as convergence. In the first turn, you want breadth. In the second, you want controlled changes. In the third, you lock the strongest candidate and prepare it for handoff to modeling or paint-over. This process helps reduce the number of off-brief concepts that waste review time.

Workflow 2 — AI image generation for game UI elements

UI is a different production problem, but it still benefits from an AI game asset generator. Game UI teams need icons, meters, inventory badges, menu elements, quest markers, and HUD fragments that match the tone of the game without needing a fully rendered illustration for every single component. Nano Banana 2 is a good fit for this because it can generate batches of small visual assets quickly and keep the style consistent across sets.

The main constraint in UI work is readability. A beautiful icon is useless if it becomes muddy at 64 pixels or loses contrast against a busy background. That means prompts need to include line weight, shape clarity, edge contrast, fill style, and a strong negative constraint list. It also means the output ratio matters. Some UI assets are square. Others need long horizontal canvases for bars, overlays, or banners.

Batch icon generation workflow

A good batch workflow starts with a style guide rather than a single prompt. Define line thickness, material treatment, icon border treatment, and background transparency expectations. Then generate sets by category, such as consumables, weapons, status effects, and crafting materials. This keeps the set coherent and helps the UI artist review icons as a family instead of as isolated images.

For example, a prompt for a fantasy RPG icon set might specify “top-down icon, dark outline, high contrast, limited palette, centered object, transparent background, no text, no perspective distortion.” That sounds simple, but it encodes the practical constraints that matter at small sizes. If your pipeline is generating hundreds of icon candidates, those constraints prevent a lot of cleanup work.

Aspect ratio guidance for game UI assets

Aspect ratio decisions should be tied to the final UI surface. Use 1:1 for inventory icons, skill icons, item cards, and status badges. Use 16:9 or 21:9 for menu splash screens, event banners, and loading scenes. Use 9:16 when the asset is intended for vertical mobile interfaces or short-form promotional layouts. The newer extreme ratios, 1:4, 4:1, 1:8, and 8:1, are especially useful for narrow HUD bars, long stat strips, marquee banners, and special event ribbons.

That flexibility matters when you are building a game tool. A studio does not want to fight the generator by resizing square outputs into awkward banners. It wants the source image to already match the intended use. If you are shipping a UI asset pipeline, encode these ratios directly into presets rather than making artists type them every time.

Workflow 3 — AI game asset generator for environment textures and concept art

Environment work is where grounding becomes especially valuable. A fantasy city, a sci-fi colony, a ruined fortress, or a desert outpost all benefit from visual references if the goal is believable world-building rather than pure abstraction. This is where an AI game asset generator shifts from “generate ideas” to “support production reference.”

The same model can also help with texture generation. In game production, a tileable texture is one that repeats without visible seams when mapped across a surface. That matters for walls, floors, terrain patches, cloth surfaces, and any other repeating material in a 3D engine. If a texture is not tileable, the seam will show up in-engine and the environment team will spend time fixing it.

Grounded environment concepts for world-building accuracy

Use grounding when the environment brief depends on real-world structure. If you are generating a fortress inspired by Iberian stonework, a nomad camp informed by desert materials, or a trade city with specific architectural influences, the generator should have reference access. That reduces generic shapes and helps the output reflect the material logic of the source inspiration.

This does not mean every fantasy scene should be grounded. In a stylized world, too much factual reference can work against the art direction. But for anything tied to a historical or real-world cultural anchor, grounding improves the odds that the first pass will be useful. It also gives the environment artist a stronger base for paint-over or blockout planning.

Texture generation for 3D game materials

Texture generation should be treated as a separate task from environment concept art. A concept image can be detailed and cinematic. A texture must be functionally repeatable. The prompt should include “tileable,” “seamless,” and the material class, such as stone, bark, metal, mud, fabric, or plaster. You should also specify the level of surface damage and the kind of wear expected, because a pristine texture and a weathered texture solve different production problems.

For example, a sandstone wall texture prompt might ask for evenly distributed erosion, no central focal point, and no framing composition. That keeps the model from producing an illustration when what the engine needs is a material. If you are building an internal tool, a separate texture mode is cleaner than trying to reuse the same prompt template for concept art and materials.

Workflow 4 — AI image generation for marketing key art and store page assets

Marketing is where studios often want hero quality, not just volume. Store capsules, feature banners, teaser images, and social assets carry the first impression for the project. That is why this workflow needs routing logic. Nano Banana 2 is ideal for volume assets and iterative exploration. Nano Banana Pro, exposed on WisGate as gemini-3-pro-image-preview, is the better choice for hero assets that need more presentation polish.

The rule is simple: route draft volume to Nano Banana 2 and final hero assets to Nano Banana Pro. This is not about abstract model loyalty. It is about matching cost, speed, and presentation value to the asset’s role. If the asset appears on a store page or in a trailer still, escalate it. If it is part of a fast exploration loop, keep it on the volume path.

Routing logic between Nano Banana 2 and Nano Banana Pro

A practical routing table can be implemented with three buckets. Use gemini-3.1-flash-image-preview for character batch drafts, UI icons, environment tests, and large iteration runs. Use gemini-3-pro-image-preview for final key art, polished storefront images, and situations where the output will be seen by players before it is seen by a design team. If a request is grounded and needs image search references, make sure the call path respects the Gemini-native endpoint requirement.

This split gives product teams a way to manage cost without sacrificing the parts of the pipeline that matter most. The team can run many low-cost iterations on Nano Banana 2, then selectively promote the strongest candidates to Pro when the composition is close and the art direction is locked.

Platform-specific asset specs for marketing output

Marketing assets should be generated with destination constraints in mind. Steam capsules, app store preview art, social banners, and video platform thumbnails all have different composition needs. A 1:1 crop may work for a social preview, while a 16:9 or 21:9 canvas fits trailer frames and broader banners. Long strips can help with announcement headers or campaign ribbons, especially when the art needs a title-safe area.

For a team building tools, this means the prompt UI should include destination presets. Instead of asking artists to remember every ratio and format, the system can map asset type to output shape automatically. That kind of workflow support is what makes an AI image generation tool feel production-ready rather than experimental.

Workflow 5 — Multi-turn AI game asset generator iteration sessions

Multi-turn iteration is where concept approval becomes manageable. A single turn can generate useful options, but game teams usually need a controlled sequence: explore, narrow, polish. That is especially true when a creative director, a lead concept artist, and a production designer all want different things from the same image. The model should support that process rather than fight it.

The value here is continuity. When the same image stays within the same thread of art direction, changes are easier to interpret. You can ask for a narrower weapon profile, a cleaner chest silhouette, a darker material read, or a more readable face shape without forcing the team to start over. That keeps the approval loop short enough to be useful.

Full session example for concept iteration

A realistic session might start with a broad prompt for a faction scout. The first turn produces four or five variants with different silhouettes. The art director chooses the strongest one and asks for longer coat tails, a less ornate mask, and a clearer shoulder shape. The second turn tightens those features while preserving the original pose language. The third turn cleans up the final version for handoff.

That sequence is straightforward, but it solves a real production problem. The team can compare progress instead of replacing entire sheets. For an AI game asset generator, this is one of the main reasons to prefer a model that handles iterative refinement well. It reduces churn in the approval process and gives the team a path from rough idea to production-ready reference.

Prompt engineering for AI image generation in game art

Prompt engineering for game art is less about poetic language and more about production control. The model needs to understand silhouette, camera, color, and constraints. If those four areas are vague, the output becomes hard to review. If they are explicit, the generator can produce assets that are more likely to fit into a studio workflow.

This is where many general-purpose examples fall short. They show pretty prompts, but they do not explain how to make outputs readable in a UI, how to keep a character recognizable across batches, or how to prevent a texture prompt from turning into an illustration. In production, the prompt is part of the pipeline contract. It should describe what the art must preserve and what it must not invent.

Silhouette, camera, color, and negative constraints

Silhouette should be the first constraint for characters and creatures. If the silhouette reads cleanly in grayscale, the concept is usually easier to approve. Camera language should be unambiguous, such as front view, three-quarter view, top-down icon, or orthographic texture plate. Color should reflect the faction or material system, not just mood words. Negative constraints should block common failures like extra limbs, cluttered backgrounds, unreadable UI text, or unnecessary perspective distortion.

The practical effect is cleaner review. Art directors do not need to spend time decoding the image’s intent. The output already matches the production purpose. This is especially valuable when your generator is being used by non-artists inside a studio tool.

Resolution guide by asset type

Use 2K for draft review, concept exploration, and batch iteration. Use 4K for hero presentation assets, marketing key art, and any image that may be shown externally. For quick internal tests, 1K or 0.5K can be enough to validate composition and prompt direction. The important thing is to match resolution to decision stage. Sending every draft to 4K wastes time and encourages teams to overfocus on details that may not survive the next revision.

Resolution also affects how the workflow feels to users. A well-designed tool lets the artist pick draft or hero mode without thinking about backend mechanics. That keeps the experience closer to a studio utility and less like a generic image toy.

Nano Banana 2 integration architecture for game studio tools

A useful AI game asset generator is not just a model call. It is an integration architecture. The model has to fit into concept review, asset tracking, versioning, and delivery. If you are building a product for studios, the backend should reflect how art teams actually work: prompt creation, batch generation, selection, refinement, export, and handoff.

The simplest architecture has a front-end prompt builder, a backend job queue, a model router, and storage for outputs and feedback metadata. That is enough to support concept art batches and UI sets. More advanced setups can add project bibles, reference libraries, and per-franchise style presets. The 256K context window makes those richer prompts more practical because you can keep more direction in a single session.

Standalone concept art pipeline

A standalone pipeline is a good starting point for internal tools. The artist enters a brief, selects an asset type, chooses a ratio and resolution, and submits a batch job. The backend sends the prompt to gemini-3.1-flash-image-preview, stores the results, and surfaces them in a review board. The reviewer can then send selected items back into a refinement loop or export them for paint-over.

That structure is easy to understand and easy to debug. It also gives product teams a clear place to insert logging, usage analytics, and approval tags. If you are building for studios, that kind of instrumentation matters because it tells you which prompts work, which asset types take the most revisions, and where the tool is reducing time.

Multi-model routing architecture

A multi-model router lets you separate volume generation from final presentation. Drafts, early concepts, and batch variations go to gemini-3.1-flash-image-preview. Hero art, store page materials, and final marketing assets go to gemini-3-pro-image-preview. If a brief needs real-world grounding, the router also checks whether the request should go through the Gemini-native endpoint.

This gives the product a clear operational logic. It prevents teams from paying hero costs for every concept and keeps the artist experience simple. The model choice becomes a function of asset type rather than a manual decision every time. For a studio tool, that is a much better default.

Unity and Unreal plugin pattern

For engine-side workflows, a plugin pattern can reduce friction. In Unity or Unreal, an artist could trigger generation from the editor, choose a preset, and auto-import outputs into a texture or concept reference folder. The plugin should keep the prompt template visible, expose ratio and resolution fields, and allow quick re-run from the editor without switching to another app.

That does not mean every generated asset belongs directly in a build. It means the editor can act as a bridge between art direction and implementation. For concept references, that bridge is enough. For materials and UI slices, it can speed up iteration by keeping the asset close to the environment or interface being built.

Async batch generation for large asset runs

Batch runs should be asynchronous. A studio may need dozens or hundreds of outputs, and blocking a UI thread for each request is not practical. Queue the jobs, poll status, and let the user review completed assets in waves. This is also where the 35-second timeout setting matters. It gives requests enough space to complete while keeping the system responsive.

For teams building a SaaS tool, async handling also supports usage tracking and retry logic. If one output fails, the rest of the batch should continue. That is basic pipeline hygiene, but it is easy to miss when a prototype becomes a product.

Cost model for AI game asset generator workflows

Cost is where production conversations become concrete. A senior-character concept at $400–$1,200 is a meaningful line item, especially when a roster needs many variations. A 30-character roster can run $60,000–$180,000 in traditional production. A 500-item UI icon set can cost $25,000–$75,000. A 20-environment concept set can cost $8,000–$24,000. A full game marketing pack can land between $15,000 and $50,000.

By comparison, the WisGate cost for the same kinds of outputs is dramatically lower at the request level, with gemini-3.1-flash-image-preview priced at $0.058 per image/request. That does not eliminate the need for artists. It changes what the team spends time on. Instead of paying people to produce every exploratory variant manually, the studio can spend more of the budget on final judgment, polish, and implementation.

Traditional production vs WisGate cost comparison

The following table captures the production delta for common game asset workloads.

The scaling math is just as direct.

If you are building a product around an AI game asset generator, this is the kind of table that matters to buyers. It turns model access into a budget conversation.

SaaS margin implications for product teams

The pricing delta also matters for SaaS design. If a tool charges $1 per concept and the generation cost is $0.058, the gross margin is 94.2%. If enterprise licensing is priced at $5 per concept, the margin rises to 98.8%. Those are the kinds of economics that make a specialized creative tool commercially viable, provided the product can control usage and route workloads correctly.

The point is not that every studio should charge the same way. The point is that low generation cost creates room for product design. You can offer drafts, refinements, project libraries, and batch runs without pricing the tool out of reach for teams that need high throughput.

Getting started with Nano Banana 2 on WisGate

Getting started is straightforward if you treat it like any other production integration. First, sign up at https://wisgate.ai. Then get an API key at https://wisgate.ai/hall/tokens. If you want to test without wiring authentication immediately, open https://wisgate.ai/studio/image and validate prompts in Studio first. For game asset workflows, use the Gemini-native endpoint when grounding or imageConfig is required.

The rest is mostly operational discipline. Set the timeout to 35 seconds. Use 2K for drafts and 4K for hero or presentation assets. Enable grounding for real-world-referenced historical or environment briefs. Disable grounding for style-consistent batch character generation. Route hero assets to Nano Banana Pro and volume work to Nano Banana 2. If you need a model comparison page, https://wisgate.ai/models is the right place to inspect options in a platform context.

Access checklist and endpoint reference

Here is the practical checklist for a studio team or a product developer integrating the workflow.

1. Sign up at https://wisgate.ai.
2. Create or copy an API key from https://wisgate.ai/hall/tokens.
3. Open https://wisgate.ai/studio/image to test prompts in Studio.
4. Use the Gemini-native endpoint for workflows that need grounding or imageConfig.
5. Set request timeout to 35 seconds.
6. Use 2K for drafts and 4K for hero/presentation assets.
7. Enable grounding for real-world-referenced historical or environment briefs.
8. Disable grounding for style-consistent batch character generation.
9. Route hero assets to Nano Banana Pro and volume assets to Nano Banana 2.

For a direct API example, the following curl call uses the WisGate endpoint with tools and imageConfig included.

curl -s -X POST \
  "https://wisgate.ai/v1beta/models/gemini-3.1-flash-image-preview:generateContent" \
  -H "x-goog-api-key: $WISDOM_GATE_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{
      "parts": [{
        "text": "Da Vinci style anatomical sketch of a dissected Monarch butterfly. Detailed drawings of the head, wings, and legs on textured parchment with notes in English."
      }]
    }],
    "tools": [{"google_search": {}}],
    "generationConfig": {
      "responseModalities": ["TEXT", "IMAGE"],
      "imageConfig": {
        "aspectRatio": "1:1",
        "imageSize": "2K"
      }
    }
  }' | jq -r '.candidates[0].content.parts[] | select(.inlineData) | .inlineData.data' | head -1 | base64 --decode > butterfly.png

If you need a hero-asset route example, the same endpoint pattern applies to gemini-3-pro-image-preview at https://wisgate.ai/v1beta/models/gemini-3-pro-image-preview:generateContent. That is the right place to send final marketing art or any image that deserves the higher-polish path.

Conclusion — What this means for game studios and AI product developers

An AI game asset generator is most valuable when it reduces concept bottlenecks without creating new workflow problems. Nano Banana 2 does that well for volume, iteration, and production-friendly asset categories like character concepts, UI elements, environment references, and marketing drafts. The model becomes even more useful when you route grounded work correctly, keep the prompt structure disciplined, and reserve Nano Banana Pro for hero assets that need final presentation treatment.

For studios, the practical result is less time spent on dead-end exploration and more time spent on choices that affect the game. For AI product developers, the opportunity is to build a tool that understands art direction, batch consistency, and cost control instead of just image output. That is what turns an image model into a useful game pipeline component.

The main takeaway is simple. Use Nano Banana 2 for the volume and iteration layer, route grounded work through the Gemini-native path when real-world reference matters, and keep your asset logic tied to the actual needs of the studio pipeline.

Get the API key, test in Studio, and start wiring the workflow into your pipeline today at https://wisgate.ai/hall/tokens and https://wisgate.ai/studio/image.

Additional implementation note: model identifiers and production specs

For teams who need the exact identifiers in their tooling, keep these values unchanged in your configuration:

• gemini-3.1-flash-image-preview
• gemini-3-pro-image-preview
• Price on WisGate: $0.058/request
• Official price: $0.068/request
• Generation time: 20 seconds
• Context: 256K tokens
• Resolution: 0.5K, 1K, 2K, 4K
• Edit rank: NB2 #17, score 1,825
• Edit rank: Pro #2, score 2,708
• Aspect ratios: 1:4, 4:1, 1:8, 8:1, 1:1, 16:9, 9:16, 21:9

Those values are the backbone of the routing logic described above. When they are kept intact in a studio tool, the workflow stays predictable and the team can make decisions based on asset type rather than guesswork.