Nano Banana 2.1 Runs on Gemini 3.6 Flash: Read the Model Card Before the Hype

Nano Banana 2.1 appeared in Google's model documentation in early October with almost no keynote fanfare, and its model card was published on October 6, 2026. It is a member of the Gemini 3 series and it is based on Gemini 3.6 Flash. It takes text and images as input with a token context window of up to one million, and it produces image output on a 4K token budget alongside text output up to 64K tokens. Image and text output are generated in the response. Read that list twice, because a lot of product decisions live inside it.

A model card is a specification, not marketing

What the model card actually says

Nano Banana 2.1 is described as a natively multimodal reasoning model that comprehends input from text and images and generates image and text output in the response. It is based on Gemini 3.6 Flash, which is the single most useful line in the document, because it tells you where this model sits in the family rather than letting you guess from a product name. Inputs are text strings and images, up to a one-million-token context. Outputs are an image with a 4K token output budget and text with a 64K token budget. Model cards may be updated over time to include new evaluations, so treat the date as part of the spec.

# The model card is a spec. Encode it, then assert against it in CI
# so nobody discovers a limit in production.
import json

SPEC = {
    'model_family':   'Gemini 3 series',
    'based_on':       'Gemini 3.6 Flash',
    'inputs':         ['text', 'image'],
    'input_context_tokens': 1_000_000,   # up to 1M
    'image_output_tokens':  4_000,
    'text_output_tokens':   64_000,
    'published':      '2026-10-06',
}

def preflight(prompt_tokens, images, want_text):
    assert prompt_tokens <= SPEC['input_context_tokens'], 'prompt exceeds 1M context'
    assert images, 'this is a text-and-image model; send an image'
    assert want_text <= SPEC['text_output_tokens'], 'text output cap is 64K'
    return True

Why model cards deserve more attention than launch posts

A launch post tells you what a model can do in a demo. A model card tells you what it is intended for, where its limitations are, how it was evaluated, and what content-safety mitigations exist. Those sections are the ones that decide whether the model fits your product, and they are the ones nobody reads. The practical habit is to turn the card into assertions in your codebase: if the card says up to 1M input tokens and 4K image output tokens, then a preflight check that rejects oversized requests is just the card made executable. When the card is revised, the failing assertion tells you which of your assumptions moved.

# Benchmark image models on YOUR prompts. A generic leaderboard tells
# you nothing about whether your product looks right.
import hashlib, json, pathlib

def build_eval(prompt_dir, out='eval_set.jsonl'):
    rows = []
    for p in sorted(pathlib.Path(prompt_dir).glob('*.txt')):
        text = p.read_text(encoding='utf-8').strip()
        rows.append({'id': hashlib.sha1(text.encode()).hexdigest()[:12],
                     'prompt': text,
                     'source': p.name,
                     'must_hold': _constraints(text)})
    pathlib.Path(out).write_text(
        '\n'.join(json.dumps(r, ensure_ascii=False) for r in rows), encoding='utf-8')
    return rows

def _constraints(text):
    # what a human would check, written down so a machine can check it too
    return {'aspect_ratio': '16:9', 'no_extra_limbs': True, 'brand_text_exact': True}

Build the eval set before you build the pipeline

Built on Gemini 3.6 Flash, and why that matters

Image models are rarely standalone systems. They are usually a diffusion or generation component attached to a language model that interprets the prompt, plans the composition and decides when the result is good enough. When the card states that Nano Banana 2.1 is based on Gemini 3.6 Flash, it is telling you what kind of reasoning sits underneath the pixels. That has consequences for prompt style, for latency expectations and for how much instruction-following you should assume versus how much you need to verify. It also means your evaluation should include the reasoning behaviour, not just the picture.

# Generation cost is dominated by repeats. Cache by a hash of the
# full request so a retry does not buy the same picture twice.
import hashlib, pathlib, json

CACHE = pathlib.Path('gen-cache'); CACHE.mkdir(exist_ok=True)

def cache_key(prompt, image_sha, params):
    blob = json.dumps({'p': prompt, 'i': image_sha, 'params': params},
                      sort_keys=True, ensure_ascii=False)
    return hashlib.sha256(blob.encode()).hexdigest()[:32]

def get_or_generate(key, generate):
    hit = CACHE / f'{key}.json'
    if hit.exists():
        return json.loads(hit.read_text(encoding='utf-8'))['asset'], True
    asset = generate()
    hit.write_text(json.dumps({'asset': asset}), encoding='utf-8')
    return asset, False

Pricing is not on the model card

Model cards cover capability and safety, not billing, and it is worth being disciplined about that separation. Press coverage described a notable price reduction for this generation of the model, but a reported figure is not a contract. Confirm current rates on Google's pricing documentation before you put a number in a budget, and confirm the exact model identifier and parameter names in the developer documentation before you put them in code. The cost that actually matters is per finished asset, not per token: generation pipelines that retry are where image budgets quietly double.

# Log what a generation actually cost, per asset, from day one.
# You cannot optimise a line item you never recorded.
import json, time, pathlib

LOG = pathlib.Path('gen-usage.jsonl')

def record(asset_id, input_tokens, image_tokens, text_tokens,
           price_in, price_img, price_text, latency_ms, attempt):
    row = {
        'ts': time.strftime('%Y-%m-%dT%H:%M:%S%z'),
        'asset': asset_id, 'attempt': attempt,
        'input_tokens': input_tokens,
        'cost_usd': round((input_tokens * price_in
                           + image_tokens * price_img
                           + text_tokens * price_text) / 1e6, 6),
        'latency_ms': latency_ms,
    }
    with LOG.open('a', encoding='utf-8') as fh:
        fh.write(json.dumps(row, ensure_ascii=False) + '\n')
    return row

# Log attempts, not just successes. Retry rate is where image budgets go.

Cache and dedupe: generation cost is dominated by repeats

What to evaluate before you ship

Build the evaluation set from your own prompts, not from a generic leaderboard, because a leaderboard measures someone else's distribution. Write down the constraints a human would check - aspect ratio, text rendering accuracy, anatomical plausibility, brand colour fidelity - and check them mechanically wherever you can, because image regressions are invisible in aggregate metrics and obvious to users. Log input tokens, image tokens, text tokens, latency and attempt number for every asset from day one. Then cache aggressively on a hash of the full request, so a retry never buys the same picture twice.

# Wrapping the provider means you can swap it without a refactor.
# It also means you can see exactly which fields you actually depend on.
from dataclasses import dataclass

@dataclass
class GenResult:
    image_b64: str
    text: str | None
    model_id: str
    latency_ms: int

def generate_image(prompt: str, image_b64: str | None, *, model_id: str,
                   aspect_ratio: str = '16:9', want_text: bool = False) -> GenResult:
    # Confirm the current model id and parameter names in Google's
    # developer documentation before wiring this into production.
    raise NotImplementedError('wire to the provider SDK you use')

# The point is the seam. A provider wrapper is what lets you change
# your mind about the model without changing your product.

Keep a seam between your product and the provider

Wrap the provider behind your own interface, even if it is a thin data class and one function. This is not architecture astronautics; it is the difference between changing your mind about a model in an afternoon and changing it across forty files. It also documents, in one place, exactly which response fields you depend on, which is what you need when a model is revised. Generation models change fast, model cards get updated, and pricing moves. The teams that cope are the ones whose product calls a function they own, not a vendor SDK they sprinkled everywhere.