Questo articolo non è ancora disponibile nella tua lingua; mostriamo l'originale.
Blog

Comparison

FIBO 2.0 Comparison: How to Choose an Image Model and Migrate

A developer's guide to FIBO 2.0 text-to-image and image-to-image routes, flat per-image pricing, and a low-risk migration path

Nov 16, 2026 11 min read
Cover art: stepped horizontal color bands descending like a barometric chart on a warm sand ground, terracotta and ochre blocks in a restrained geometric composition.
In questa pagina

What FIBO 2.0 Actually Offers

FIBO 2.0 is an image model family with two routes you can call today:

  • Text-to-image (fibo-2.0-text-to-image) — you send a prompt, you get an image. Optional inputs let you steer aspect ratio, seed, photographic style, and a reference image URL.
  • Image-to-image (fibo-2.0-image-to-image) — you send one to four image URLs plus an instruction describing what to change, and you get an edited image back. An optional mask limits edits to a region.

Both routes share the same output type (image), the same seed semantics (default 5555, reproducible), and the same billing unit (per image). What separates them is the input contract: the text route is prompt-first, while the image route is edit-first and requires image_urls and instruction.

The practical implication is that "FIBO 2.0" is not one endpoint with a flag. When you compare it against another model, compare against the specific route whose input shape matches your job. A prompt-only generator and an instruction-driven editor are different products even when they share a family name.

One model family, two visible routes: a text-origin path and an image-origin path each resolve into its own stepped outcome.

Comparing FIBO 2.0 Against Other Image Models

Model comparisons tend to collapse into benchmark screenshots. For integration work, four axes matter more:

1. Task fit

Does the model generate from a prompt, edit an existing image, or both? FIBO 2.0 covers both, but through two separate routes with different required parameters. If your pipeline only ever creates images from text, the text-to-image route is the whole story. If you need "change this photo," the image-to-image route is the one to evaluate.

2. Input flexibility

Count the inputs a route accepts. FIBO 2.0 image-to-image takes 1–4 public image URLs — the first is the image to edit and up to three more are references the instruction can address as <image_1>, <image_2>, and so on. That ordering is part of the contract, so check whether a competing model's multi-image semantics line up or would force you to reorder your assets.

3. Parameter surface

List the knobs and their enums. FIBO 2.0 exposes a broad aspect_ratio enum (from 1:1 through 21:9, 3:1, and 5:1), a seed defaulting to 5555, four style presets, and on the edit route an optional mask_url. A model with fewer knobs is not automatically worse — it is less work to keep stable. A model with more knobs may conflict internally; FIBO 2.0 is explicit that style and a reference image cannot be combined, which is the kind of rule you want documented rather than discovered.

4. Billing model

Ask what the unit is. FIBO 2.0 bills per image at a single flat rate for both routes. Models that bill by pixel tier, step count, or resolution bucket make forecasting harder and make route choice affect cost. A flat unit means your spend estimate is a multiplication you can do in advance.

Run the same four questions against every candidate and the decision usually makes itself: the model that matches your input shape, has no conflicting parameters you need, and bills in a unit you can forecast is the one to prototype.

The four evaluation axes as stepped strata: each column a candidate, each row a decision dimension.

Reading the Pricing: Flat Per-Image Billing

FIBO 2.0 uses one billing unit — per image — and a single flat rate applied identically to the text-to-image and image-to-image routes. There are no resolution tiers or step-based multipliers in the published price.

That simplicity is the feature. Cost estimation becomes:

expected_images_per_day * days = billable_images
billable_images * flat_per_image_rate = spend

Three consequences worth planning around:

  • Route choice does not change cost. Editing an existing image and generating a new one bill the same per output image. You can pick the route that fits the task without a cost penalty pushing you toward one or the other.
  • Input count does not change cost. Sending four image URLs to the edit route still produces one billed image. Budget by outputs, not by inputs.
  • Retries and regenerations do. Every produced image is billed. A test loop that regenerates 50 times is 50 images of spend, which is why seed pinning and a staging environment matter for the budget as much as for output quality.

The official rate on both routes is $0.0572 per image. There is no resolution parameter and no resolution-tier multiplier; output uses aspect_ratio at about one megapixel. Confirm the live panel on the model pages if you need to re-check, and integrate against this official flat rate.

Parameter Differences That Change Output

Not every parameter matters equally. Here is what actually alters the pixels, and what conflicts with what.

Shared across both routes

  • seed — integer, default 5555, range up to 2147483647. The same seed and inputs reproduce the same result. This is your reproducibility lever and the single most important parameter for testing.
  • aspect_ratio — a large enum covering square, portrait, landscape, and extreme ratios like 21:9, 3:1, and 1:5. Output is about one megapixel regardless of ratio, so changing the ratio reshapes the canvas rather than increasing detail. On text-to-image the default is 1:1. On image-to-image, omitting it follows the first input image, and a single-image edit always keeps that image's ratio.

Text-to-image only

  • prompt — required, up to 10,000 characters.
  • style — one of Kodak Film, Hard Flash, Hazy Dreamy, Rough Realism. A photographic look, not a content instruction.
  • image_url — a public URL used as a visual reference for the prompt's scene.

Conflict: style and image_url cannot be combined. Design your prompt templates around one path or the other; a template that conditionally sets both will fail.

Image-to-image only

  • image_urls — required, 1 to 4 public URLs. Order is semantic: the first is the image to edit, the rest are references addressable in the instruction.
  • instruction — required, up to 10,000 characters. Describes what to change.
  • mask_url — optional, and only valid when image_urls contains exactly one image. White marks the edit area, black is kept, and the mask must match the image size.

Conflict: a mask with multiple images is invalid. If you need region-limited edits across references, do the masked edit on a single image first.

Style and reference images fork into separate paths and never merge; the mask notch fits only a single-image band — a map of which parameters can coexist.

Choosing Between Text-to-Image and Image-to-Image

The selection rule is one question: does an image already exist?

If the answer is no — the job is "produce an image from a description" — use text-to-image. It is prompt-first, supports a style preset or a single reference image (not both), and lets you pin an aspect ratio and seed. Typical uses: hero images, illustrations, variations of a described scene.

If the answer is yes — the job is "change this image" — use image-to-image. The instruction is the edit, and image_urls is the material. Reach for it when you need to restyle a photo, swap an element, or blend references under instruction. Add mask_url when the change must be confined to a region of a single image.

A few tie-breakers:

  • You have a reference photo but want a new scene. That is text-to-image with image_url as the visual reference, not an edit. The prompt still drives the content.
  • You want a photographic look applied to a prompt. Use style on text-to-image. Do not try to emulate it by passing a style reference image — the two are mutually exclusive by design.
  • You need multiple references combined. Only image-to-image accepts up to four URLs, and only it lets the instruction address them by index.

When in doubt, prototype both routes with the same seed and compare. The route whose required inputs you can fill without hacks is usually the right one.

Migrating an Existing Image Pipeline

A migration is a change of contract, not just a change of URL. Treat it in stages.

1. Map inputs to the target route

Inventory every call your pipeline makes and classify it as generate or edit. Generation calls map to text-to-image: your existing prompt becomes prompt, and any style tokens in your prompt template should be lifted into the style enum if they match one of the four presets. Edit calls map to image-to-image: your source image becomes the first entry in image_urls, and your modification text becomes instruction. Rewrite instructions to name references explicitly — <image_1>, <image_2> — since that is how the route addresses multiple inputs.

2. Pin seeds

Set seed explicitly in every test and fixture. The default is 5555; relying on it silently means every unpinned call reproduces the same image, which masks prompt bugs and inflates confidence. In production, change seeds deliberately and record which seed produced which approved asset.

3. Shadow run

Send a sample of real traffic to the new route without serving its output. Compare two things per request: output acceptability against your existing quality bar, and billed image count against your forecast. Because billing is per image on both routes, the spend comparison is a straight count.

4. Cut over with a rollback

Switch a small percentage of live traffic, keep the old path warm, and watch failure rates by parameter combination — especially the mutually exclusive pairs (style with image_url, mask_url with multiple images). Roll back on error-rate or quality regression; the flat per-image unit makes the cost side of a rollback trivial to reason about.

5. Clean up

Once stable, delete dead prompt templates, collapse duplicated style logic into the enum, and document which route each job uses so future changes do not re-cross the boundary.

Common Integration Pitfalls

Most failures are contract violations rather than model quality issues.

  • Combining style with image_url. These are mutually exclusive on text-to-image. A template that sets both — often because the style was added later — fails. Pick one path per request.
  • Masking a multi-image edit. mask_url is valid only when image_urls has exactly one entry. Sending a mask alongside references is rejected. Split the job: masked single-image edit first, reference-guided pass second.
  • Mismatched mask size. The mask must match the image size and uses white-for-edit, black-for-keep. An inverted or resized mask produces plausible-looking but wrong output rather than an error, so validate dimensions before sending.
  • Unpinned seeds. With a default of 5555, forgetting to set a seed makes outputs look deterministic when they are just identical. Tests pass, then a prompt edit changes everything at once. Pin seeds in fixtures and vary them intentionally.
  • Assuming aspect ratio follows the input on edits. Only a single-image edit guarantees the input ratio. Multi-image edits should set aspect_ratio explicitly, or they follow the first image and may crop badly.
  • Treating retries as free. Each produced image is billed. Retry loops without backoff or deduplication quietly multiply spend; log the billed count per request so it is visible.
  • Reordering image_urls. Because instructions refer to images by index, reordering the array silently changes what <image_2> means. Freeze the order at the call site.

When FIBO 2.0 Is the Right Fit

FIBO 2.0 is a strong match when:

  • Your pipeline has both generation and editing jobs and you want one family with a shared seed and billing model rather than two vendors.
  • You need multiple references in an edit — up to four images, addressable by index — or region-limited edits via a mask on a single image.
  • Your forecasting needs a single flat per-image unit so spend scales with output volume and nothing else.
  • You want reproducible outputs through a seed you control, with a documented default of 5555.
  • You need a wide aspect-ratio range, including extreme banners and portrait formats, at roughly one megapixel.

Look elsewhere when:

  • Your only job is prompt-to-image with a fixed style and you value the smallest possible parameter surface over flexibility.
  • You need a resolution tier or capability not present in the published enums — do not assume one exists.
  • Your edits routinely require masks across multiple images; that combination is out of scope by design.

If the signals line up, start with the text-to-image route for generation jobs and the image-to-image route for edits, pin your seeds, and run a shadow comparison before you move live traffic.

Inizia a creare con artefatti IA persistenti

Ottieni la tua chiave API e chiama modelli di immagini, video e audio tramite un'unica API basata sui task.

Leggi la documentazione API