AI Skill
Review
Audit score 70

nano-banana-edit

agentspace-so/runcomfy-agent-skills

Edit images with Google Nano Banana 2 on RunComfy — batch up to 20 inputs, preserve identity, swap backgrounds, localize edits.

What is nano-banana-edit?

nano-banana-edit is a skill for coding agents that wraps the Google Nano Banana 2 image-to-image edit endpoint via the RunComfy CLI. It supports 1–20 input images per call, identity-preserving edits, background swaps, spatial language for localized changes, and batch consistency with locked aspect ratios. The skill documents the full input schema, prompting best practices, model selection guidance (vs. GPT Image 2 edit, Flux Kontext, and Nano Banana 2 t2i), and CLI exit codes.

  • Calls `runcomfy run google/nano-banana-2/edit` to perform image-to-image edits using Google Nano Banana 2
  • Supports batch editing of 1–20 input images in a single call
  • Preserves subject identity, pose, and clothing while swapping backgrounds or making localized changes
  • Honors spatial language in prompts (e.g., 'left object only', 'upper-right corner') for targeted edits
  • Outputs 1–4 images per call with configurable resolution (0.5K–4K), format (png/jpeg/webp), and aspect ratio
  • Routes to sibling models (GPT Image 2 edit, Flux Kontext, Nano Banana 2 t2i) when they are a better fit

How to install nano-banana-edit

npx skills add https://github.com/agentspace-so/runcomfy-agent-skills --skill nano-banana-edit
Prerequisites
  • RunComfy CLI installed globally: `npm i -g @runcomfy/cli`
  • RunComfy account — authenticate with `runcomfy login` (browser device-code flow)
  • For CI/containers: set `RUNCOMFY_TOKEN=<token>` environment variable instead of interactive login
  • Input images must be publicly fetchable HTTPS URLs
  • Node.js environment capable of running `npx` to install the skill
Claude Code
Cursor
Windsurf
Cline

How to use nano-banana-edit

  1. 1.Install the skill: `npx skills add https://github.com/agentspace-so/runcomfy-agent-skills --skill nano-banana-edit`
  2. 2.Ensure RunComfy CLI is installed (`npm i -g @runcomfy/cli`) and you are logged in (`runcomfy login`)
  3. 3.Prepare publicly accessible HTTPS URLs for each image you want to edit (1–20 images)
  4. 4.Write a prompt that leads with preservation goals and ends with the specific change (e.g., 'Keep subject identity unchanged. Convert background to a neon cyberpunk street.')
  5. 5.Run the edit: `runcomfy run google/nano-banana-2/edit --input '{"prompt":"...","image_urls":["https://..."]}' --output-dir <path>`
  6. 6.For batch edits, lock `aspect_ratio` and `resolution` fields and use consistent prompt grammar across all inputs
  7. 7.For localized edits, use spatial language in the prompt (e.g., 'the leftmost object only', 'bottom-right corner')
  8. 8.Check exit codes if the command fails: 77 = auth issue, 75 = retry, 65 = bad input schema, 69 = upstream error

Use cases

Good for
  • SKU gallery: apply consistent background changes across up to 20 product images in one call
  • Influencer or spokesperson background swaps with strong identity preservation
  • Localized object removal or addition using spatial prompt language
  • A/B ad creative variants using seed locking and multiple output images
  • Brand asset relocalization: swap text, palette, or background while keeping composition
Who it's for
  • E-commerce teams needing batch product image editing
  • Marketers producing A/B ad creative variants at scale
  • Developers building image editing pipelines with a coding agent
  • Designers who need consistent background swaps across image series
  • Anyone explicitly wanting to use the Nano Banana 2 edit model via CLI

nano-banana-edit FAQ

When should I use Nano Banana Edit instead of GPT Image 2 edit or Flux Kontext?

Use Nano Banana Edit for identity-preserving edits, background swaps, batch editing up to 20 images, or spatial localization. Use GPT Image 2 edit for multilingual in-image text edits. Use Flux Kontext for single-reference precise local edits like object substitution.

How many images can I edit in one call?

You can pass 1–20 input image URLs per call. The first image is treated as the primary; the rest provide auxiliary cues. Each call produces 1–4 output images.

Why is my edit drifting or changing things I didn't want changed?

Always lead your prompt with explicit preservation goals (e.g., 'Keep the subject identity, pose, and clothing unchanged.'). Avoid long compound instructions — split multi-step edits into separate passes. Missing preservation goals cause the model to subtly rewrite faces or branding.

How do I authenticate in a CI or container environment?

Set the `RUNCOMFY_TOKEN=<token>` environment variable instead of running `runcomfy login`. This avoids the browser device-code flow.

What happens if I use aspect ratios that don't match my input images?

Mismatched aspect ratios cause crops or stretches in the output. Lock `aspect_ratio` to match your input dimensions, especially when running batch edits for consistency.

Full instructions (SKILL.md)

Source of truth, from agentspace-so/runcomfy-agent-skills.


name: nano-banana-edit displayName: "Nano Banana Edit — Pro Pack on RunComfy" description: > Edit images with Google Nano Banana 2 (image-to-image edit endpoint) on RunComfy. Documents Nano Banana Edit's strengths (preserve subject identity, swap background, localize edits with spatial language, multi-image batch edits up to 20 inputs), the schema, and when to route to GPT Image 2 edit / Flux Kontext / Nano Banana 2 t2i instead. Calls runcomfy run google/nano-banana-2/edit through the local RunComfy CLI. Triggers on "nano banana edit", "edit with nano banana", "image edit nano banana", or any explicit ask to edit with this model. homepage: https://www.runcomfy.com license: MIT

Nano Banana Edit — Pro Pack on RunComfy

runcomfy.com · Edit endpoint · GitHub

Google Nano Banana 2 Edit — the image-to-image edit endpoint of the Gemini-family flash-tier image model — hosted on the RunComfy Model API. Up to 20 input images per call for batch edits and multi-reference variation.

npx skills add agentspace-so/runcomfy-skills --skill nano-banana-edit -g

When to pick this model (vs siblings)

You wantUse
Preserve subject identity, swap background or clothingNano Banana Edit
Edit up to 20 images consistently in one batchNano Banana Edit
Localize edit to "X only" with spatial languageNano Banana Edit
Edit multilingual text inside the image (signs, labels)GPT Image 2 edit
Single ref + precise local edit ("she's now holding X")Flux Kontext
Generate a new image from scratchNano Banana 2 t2i (sibling skill)

If the user said "nano banana edit" / "edit with nano banana" explicitly, route here regardless.

Prerequisites

  1. RunComfy CLInpm i -g @runcomfy/cli
  2. RunComfy accountruncomfy login opens a browser device-code flow.
  3. CI / containers — set RUNCOMFY_TOKEN=<token> instead of runcomfy login.

Endpoints + input schema

google/nano-banana-2/edit

FieldTypeRequiredDefaultNotes
promptstringyesEdit instruction. Lead with preservation, end with the change.
image_urlsarrayyes1–20 publicly-fetchable HTTPS URLs.
number_of_imagesintno11–4 outputs per call.
seedintnoReproducibility.
aspect_ratioenumnoautoauto (follows input) or fixed ratios — lock for batch consistency.
resolutionenumno1K0.5K / 1K / 2K / 4K.
output_formatenumnopngpng / jpeg / webp.
safety_toleranceintno41 (strict) – 6 (permissive).
limit_generationsboolnoIf true, restricts each round to one output.
enable_web_searchboolnofalseWeb grounding (extra cost / latency).

How to invoke

Single-image background swap, identity preserved:

runcomfy run google/nano-banana-2/edit \
  --input '{
    "prompt": "Keep the subject identity, pose, and clothing unchanged. Convert the background into a rainy neon cyberpunk street.",
    "image_urls": ["https://.../portrait.jpg"]
  }' \
  --output-dir <absolute/path>

Batch edit with locked framing:

runcomfy run google/nano-banana-2/edit \
  --input '{
    "prompt": "Replace the watermark in the bottom-right with the text \"AURA\" in clean white sans-serif. Keep everything else exactly as in the input.",
    "image_urls": ["https://.../sku-1.jpg", "https://.../sku-2.jpg", "https://.../sku-3.jpg"],
    "aspect_ratio": "1:1",
    "resolution": "1K"
  }' \
  --output-dir <absolute/path>

Targeted spatial edit ("left object only"):

runcomfy run google/nano-banana-2/edit \
  --input '{
    "prompt": "Remove the leftmost object only. Keep the right two objects, the table, and the lighting unchanged.",
    "image_urls": ["https://.../still-life.jpg"]
  }' \
  --output-dir <absolute/path>

Prompting — what actually works

Preservation first, change last. Always lead with "Keep [identity / pose / clothing / brand / framing] unchanged." Then state the change in one clean sentence. Models honor what's stated up front; tail-end preservations get ignored.

Localize with spatial language. "background only", "the left object", "the upper-right corner", "above the headline" — concrete spatial scopes are honored. "make it more X" is vague and drifts.

Batch consistency — when editing a series, lock aspect_ratio and resolution. Use the same prompt grammar across the batch so each output reads as a sibling, not a remix.

Iterate small. If a one-pass edit drifts, split into two: pass 1 changes background only, pass 2 swaps the subject's outfit. Cleaner edits, same total cost (assuming similar resolution).

Multi-image variation — pass up to 20 inputs to get a coherent batch. Useful for SKU galleries, A/B testing, character sheet variations.

Anti-patterns:

  • Long compound instructions ("change A and B and C and D") — drift increases per added scope.
  • Edit instructions written in passive voice ("the background should be changed") — be imperative.
  • Missing preservation goals — model will subtly rewrite the face / brand.
  • Aspect ratios that don't match input — causes crops or stretches.

Where it shines

Use caseWhy Nano Banana Edit
SKU gallery — same product on different backgroundsBatch of 20, identity-preserved, framing locked
Influencer / spokesperson background swapsStrong identity preservation across edits
Localized object removal / additionSpatial language honored
A/B variants for ad creativeSeed lock + multiple number_of_images
Brand-asset relocalizationSame composition with text / palette swap

Sample prompts (verified to produce strong results)

Background swap (page example):

Keep the subject identity unchanged. Convert the background into a rainy
neon cyberpunk street.

Targeted text replacement:

Keep the bottle, label, and lighting exactly as in the input.
Replace only the brand text on the label from "ALPHA" to "AURA",
same font weight, centered, white on black.

Multi-image batch consistency:

For each input image: keep the subject's pose and identity unchanged.
Convert the background to a soft warm-grey studio sweep with subtle
floor shadow. Center the subject at the same fraction of frame as the
input.

Limitations

  • 1–20 input images per call — the first is treated as primary; the rest provide auxiliary cues.
  • 1–4 outputs per call.
  • Long compound prompts drift — split into multiple passes.
  • Web search adds latency + cost — only enable on demand.
  • For multilingual in-image text edits, GPT Image 2 edit wins.

Exit codes

codemeaning
0success
64bad CLI args
65bad input JSON / schema mismatch
69upstream 5xx
75retryable: timeout / 429
77not signed in or token rejected

Full reference: docs.runcomfy.com/cli/troubleshooting.

How it works

The skill invokes runcomfy run google/nano-banana-2/edit with a JSON body matching the schema. The CLI POSTs to https://model-api.runcomfy.net/v1/models/google/nano-banana-2/edit, polls the request, fetches the result, and downloads any .runcomfy.net/.runcomfy.com URL into --output-dir. Ctrl-C cancels the remote request before exit.

Security & Privacy

  • Token storage: runcomfy login writes the API token to ~/.config/runcomfy/token.json with mode 0600 (owner-only read/write). Set RUNCOMFY_TOKEN env var to bypass the file entirely in CI / containers.
  • Input boundary: the user prompt is passed as a JSON string to the CLI via --input. The CLI does NOT shell-expand the prompt; it transmits the JSON body directly to the Model API over HTTPS. No shell injection surface from prompt content.
  • Third-party content: image / mask / video URLs you pass are fetched by the RunComfy model server, not by the CLI on your machine. Treat external URLs as untrusted; image-based prompt injection is a known risk for any image-edit / video-edit model.
  • Outbound endpoints: only model-api.runcomfy.net (request submission) and *.runcomfy.net / *.runcomfy.com (download whitelist for generated outputs). No telemetry, no callbacks.
  • Generated-file size cap: the CLI aborts any single download > 2 GiB to prevent disk-fill from a malicious or runaway model output.