Seedream 5.0 Pro Plus Private Image Workflows: Where to Version Them and Run Them Across GPUs

Run the whole pipeline in GMI Studio: the Seedream generation step and your private image steps go on one Studio canvas, the private parts are saved as reusable Blueprints, and the private stages execute on GMI Cloud's managed GPU backend, with Studio Enterprise adding "Dedicated GPU clusters" once the workflow is business-critical (GMI Studio).

Studio's Model Library lists ByteDance Seedream nodes next to ComfyUI-based building blocks, so an API model step and your own logic live in the same saved workflow instead of in two systems that drift apart (Workflow Canvas docs).

For code-driven batches, the same GMI Cloud account calls seedream-5.0-pro on Model-as-a-Service (MaaS) at $0.085 per image, as of September 2026 (Seedream 5.0 Pro model page).

GMI Cloud is an AI-native infrastructure platform for production inference that offers GPU clusters, model APIs, and workflow tooling in one cloud; GMI Studio is its "Production-Ready AI Workflow Platform", built to "Design, control, and scale AI workflows with full model customization and dedicated GPU infrastructure" (About, GMI Studio).

Which platform should manage Seedream 5.0 Pro steps and private image workflows?

GMI Studio should hold the workflow, and MaaS should serve any Seedream calls your own code makes, because a marketing image pipeline rarely ends at the Seedream call.

A typical agency graph generates a master image with Seedream, then runs private steps on it: a brand LoRA pass, a background or color correction, a crop into each channel format, a watermark or legal overlay.

If the Seedream call lives in one script and the private steps live in another tool, nobody can say which prompt, which reference set, and which LoRA version produced last Tuesday's approved hero shot.

Need (GMI Cloud answer / What it gives you)

• API model steps and private steps in one versioned unit | GMI Cloud answer: GMI Studio | What it gives you: Seedream nodes in the Model Library, "Custom nodes & private logic", "Cross-model pipelines", "Versioned workflows"
• Reusable private sub-pipelines | GMI Cloud answer: Studio Blueprints | What it gives you: "Save Selected as Template" turns a wired selection into a reusable subgraph (Library, Search & Blueprints)
• Running the private stages across GPUs | GMI Cloud answer: Studio Dedicated Infrastructure; Studio Enterprise | What it gives you: "Parallel execution across GPUs", "Single or multi-GPU execution", L40 to B200, "Dedicated GPU clusters"
• Seedream calls from your backend | GMI Cloud answer: MaaS, model ID seedream-5.0-pro | What it gives you: $0.085 per image, one request queue API, same GMI Cloud account

Assembling the same pipeline from separate vendors means a model API such as BytePlus ModelArk for Seedream and a ComfyUI host such as ComfyDeploy for the node graph, with the version record split between them.

GMI Cloud puts all three layers on one platform: Studio for the graph, MaaS for programmatic model calls, and GMI Cloud's GPU infrastructure for the private stages.

What does a mixed Seedream and private-step workflow look like in GMI Studio?

A mixed GMI Studio workflow is one directed graph where the Seedream node produces the master image and every downstream node runs your private logic.

GMI Studio's canvas "is a ComfyUI-based visual editor", and each workflow is a graph of nodes wired together through their input and output sockets (Workflow Canvas docs).

The Model Library's Image tab lists "ByteDance Seedream 3 / 4 / 5" among its models, and the canvas separates two node families: GMI Official nodes ("Quick setup, managed inference") and ComfyUI nodes ("Fine-grained control, custom logic"), the latter "sourced directly from the upstream Comfy repo".

The LLM tab is "the same catalog you see on the Inference Model Hub", so a prompt-expansion or caption-check step can call a GMI Cloud language model inside the same graph instead of from a separate script.

A six-step e-commerce campaign graph looks like this:

Step (Node / Node family / What you pin for the version record)

• 1. Brand inputs | Node: Load Image (product shot, style references) | Node family: Assets | What you pin for the version record: Reference set ID and file hashes
• 2. Master generation | Node: ByteDance Seedream node | Node family: GMI Official, Model Library | What you pin for the version record: Model entry, prompt, size, output format, watermark flag
• 3. Brand look | Node: Your LoRA or style pass | Node family: Private logic ("Custom nodes & private logic") | What you pin for the version record: LoRA file version, strength
• 4. Channel formats | Node: Crop, resize, and upscale per format (for example, ComfyUI's native ResizeAndPadImage) | Node family: ComfyUI native | What you pin for the version record: Target sizes per channel
• 5. Compliance overlay | Node: Legal text, logo lockup | Node family: Private logic | What you pin for the version record: Overlay template version
• 6. Delivery | Node: Save Image | Node family: Assets | What you pin for the version record: Output naming rule

The parameter surface is what makes this graph safe to hand to producers.

In a node's Parameters tab, each input has a __ menu to favorite it, and every favorited input appears in Workflow Overview > Parameters, which the docs call "the workflow's parameter surface": the inputs a consumer of the workflow has to fill in.

For an agency, that is the product photo, the campaign prompt, and the format list.

To keep LoRA strength and overlay settings out of a producer's hands, hand them a published version, where "the node graph is hidden, only required inputs are exposed" (Managing Workflows).

The Studio page's Marketing Automation example shows the same pattern at production scale, on video: "Studio enabled reusable, controlled video production pipelines tailored to real estate and multi-channel marketing workflows" (GMI Studio).

Which Seedream 5.0 Pro size should the master image use?

Generate every master at one of the 2K-class sizes listed for seedream-5.0-pro on GMI Cloud, then derive each delivery format in a private step.

The Size panel on the model page lists 2048x2048 (1:1), 2720x1536 (16:9), 1536x2720 (9:16), 2352x1760 (4:3), 1760x2352 (3:4), 2496x1664 (3:2), 1664x2496 (2:3), and 3120x1344 (21:9), each between 4.14 and 4.19 million pixels (Seedream 5.0 Pro model page).

BytePlus's own API reference for Seedream 5.0 Pro caps explicit sizes at 4,624,220 pixels, so every listed size sits inside the model's range (BytePlus image generation API).

That ceiling is the strongest argument for keeping the resize step in the same graph. No delivery format is generated twice, and the one format bigger than the master is handled by a private upscale step:

Delivery format (Native size / Master (from the catalog sizes) / Private step)

• Marketplace square | Native size: 1000x1000 | Master (from the catalog sizes): 1760x2352 (3:4), shared | Private step: Center-crop to 1760x1760, downscale
• Instagram portrait 4:5 | Native size: 1080x1350 | Master (from the catalog sizes): 1760x2352 (3:4), shared | Private step: Crop to 1760x2200, downscale
• Web banner 16:9 | Native size: 1920x1080 | Master (from the catalog sizes): 2720x1536 (16:9), shared | Private step: Resize to 1920x1080
• 4K hero 16:9 | Native size: 3840x2160 | Master (from the catalog sizes): 2720x1536 (16:9), shared | Private step: Upscale to 3840x2160 (about 1.41x)
• Story or Reel 9:16 | Native size: 1080x1920 | Master (from the catalog sizes): 1536x2720 (9:16) | Private step: Resize to 1080x1920

Five delivery formats need only three masters: one 3:4, one 16:9, one 9:16. Keep brand reference sets at 10 images or fewer, the limit BytePlus documents for Seedream 5.0 Pro reference inputs (BytePlus image generation API).

How do you version a workflow that mixes API calls and private logic?

Version the private parts as named Blueprints and treat the whole graph as the release unit. The Studio page lists "Versioned workflows", "Model loading & versioning", and "Controlled updates & rollback" among Studio's capabilities (GMI Studio).

The docs give the building block that makes component-level versioning practical: select any group of nodes, right-click, choose "Save Selected as Template", and it becomes a "User generated subgraph blueprint" that teammates find under Blueprints in the node search (Library, Search & Blueprints).

Once placed, a Blueprint behaves like a single node with its own inputs and outputs.

Five conventions keep a mixed graph traceable:

1. One Blueprint per private stage. Save steps 3 to 5 above as brand-look-v3, channel-crops-v2, legal-overlay-v5. The version lives in the Blueprint name, so a workflow that uses brand-look-v3 says so on the canvas.
2. Bump the Blueprint, not the workflow, for private changes. A new LoRA file becomes brand-look-v4; each campaign workflow adopts it deliberately instead of inheriting it silently.
3. Write the Seedream node's settings into the workflow description. Record the model entry, size, output format, and watermark flag. GMI Cloud's seedream-5.0-pro parameter list has no seed field (prompt, image, size, sequential_image_generation, max_images, output_format, watermark), so the version record is what makes a regenerated image comparable to the approved one.
4. Freeze the parameter surface. Producers work from the favorited and required inputs; a change to anything else means a new version.
5. Keep a manifest per approved asset. Workflow name, Blueprint versions, Seedream settings, reference set ID, run date. Studio's My Media gallery holds every asset your workflow runs have generated, so the manifest points at outputs you can still find (Managing Workflows).

Studio auto-saves on every change, and "Saving never overwrites a published workflow without confirmation." The full release and rollback routine (duplicating a known-good version, permissions in Team Space, publishing) is covered in updating and rolling back models in a private video workflow.

How does GMI Studio run the workflow across GPUs?

Studio executes the graph's GPU work on GMI Cloud's infrastructure, and you choose the GPU class and scale for the private steps.

The docs state that Studio execution runs on GMI Cloud's managed GPU backend, with an execution engine that "schedules and runs workflows on GPUs", so the team needs no local GPU setup (Introduction).

The Studio page lists the GPU classes (L40, A6000, A100, H100, H200, B200), "Single or multi-GPU execution", "Parallel execution across GPUs", and, under Dedicated Infrastructure, "No shared queues" (GMI Studio).

An agency with several clients splits execution into two tiers:

• Standard Studio execution for building and testing graphs. The Studio FAQ notes that "Queue times depend on GPU availability and overall workload demand".
• Studio Enterprise for production campaigns that need capacity reserved for the organization. It adds "Dedicated GPU clusters", "Full architectural customization", "Org-level workflow ownership", "RBAC and usage visibility", and "Production workflow support" (GMI Studio). A dedicated environment built around proprietary LoRAs and custom nodes is scoped with GMI Cloud sales at this tier.

Seedream 5.0 Pro is BytePlus's model, so treat the Seedream node as a priced API call and size GPUs for the private stages around it.

How parallel stages and batches map onto multiple cards is covered in Multi-ControlNet with private nodes on parallel GPUs.

What does the Seedream line of a campaign cost?

At the MaaS price of $0.085 per image (as of September 2026), a campaign's Seedream cost is set by how many master images the graph generates, so reusing one master across several delivery formats is the biggest cost lever (Seedream 5.0 Pro model page).

Take a campaign of 40 SKUs, 3 creative directions, and the 5 delivery formats in the size table, one generation per image:

Graph design (Seedream images per campaign / Seedream cost per campaign / 8 campaigns per month)

• One Seedream call per delivery format | Seedream images per campaign: 40 x 3 x 5 = 600 | Seedream cost per campaign: $51.00 | 8 campaigns per month: $408.00
• One master per aspect family (3:4, 16:9, 9:16), private crops and upscales for the rest | Seedream images per campaign: 40 x 3 x 3 = 360 | Seedream cost per campaign: $30.60 | 8 campaigns per month: $244.80

The second design cuts the Seedream line by 40% and keeps composition consistent across formats, because the square and the 4:5 portrait come from the same approved master.

The table covers the Seedream line only; GPU time for the private stages depends on your Studio setup, and Studio Enterprise rates come from GMI Cloud sales.

In Studio, "Runs spend credits according to the model nodes in the graph", so for canvas runs read the Seedream node's cost in Studio rather than assuming the MaaS figure (Workflow Canvas docs).

Concept boards that come before the Seedream master can run on the same GMI Cloud key; the GMI Cloud blog's hands-on test of Hy Image 3.5 Preview ran 36 calls for $0.84 (Why Hy Image 3.5 Preview Matters).

When should the Seedream step run in Studio, and when through the MaaS API?

Put Seedream in the Studio graph whenever its output feeds a private step; call seedream-5.0-pro on MaaS when your own application owns the flow. Decide by what triggers the image:

If the Seedream output... (Run it in / Why)

• Feeds a LoRA, crop, or overlay step you maintain | Run it in: Studio canvas | Why: One version record covers generation and post-processing
• Is reviewed visually by creatives before approval | Run it in: Studio canvas | Why: Producers work from the parameter surface; My Media keeps every run
• Is triggered by your PIM, CMS, or order system per SKU | Run it in: MaaS API | Why: Your backend already owns retries, storage, and naming
• Goes straight to a customer-facing app with no private step | Run it in: MaaS API | Why: No graph to version; the request payload is the record

A backend call to MaaS should pick its size from the same master table the Studio graph uses, so both paths produce comparable images; the backend then runs its own crops and overlays on the returned master.

This minimal Python client does that and submits to the request queue documented in the Seedream 5.0 Pro quickstart, with a time budget that stops new polls once it runs out:

import os
import time
import requests

BASE = "https://console.gmicloud.ai/api/v1/ie/requestqueue/apikey"
HEADERS = {"Authorization": f"Bearer {os.environ['GMI_API_KEY']}"}
MASTER_SIZES = {"1:1": "2048x2048", "3:4": "1760x2352",
                "16:9": "2720x1536", "9:16": "1536x2720"}   # catalog sizes
MAX_REFS = 10                                              # BytePlus Pro limit
def generate_master(prompt, refs, aspect, budget_s=180):
    if aspect not in MASTER_SIZES:
        raise ValueError(f"no master size for aspect {aspect!r}")
    if len(refs) > MAX_REFS:
        raise ValueError(f"{len(refs)} reference images; keep it to {MAX_REFS}")
    payload = {"prompt": prompt, "size": MASTER_SIZES[aspect],
               "output_format": "png", "watermark": False}
    if refs:
        payload["image"] = refs

    stop_at = time.monotonic() + budget_s

    def remaining():
        left = stop_at - time.monotonic()
        if left <= 0:
            raise TimeoutError(f"job exceeded {budget_s}s")
        return left

    resp = requests.post(f"{BASE}/requests", headers=HEADERS,
                         json={"model": "seedream-5.0-pro", "payload": payload},
                         timeout=min(60, remaining()))
    resp.raise_for_status()
    job = resp.json()
    while job.get("status") in ("queued", "processing"):
        time.sleep(min(3, remaining()))
        poll = requests.get(f"{BASE}/requests/{job['request_id']}",
                            headers=HEADERS, timeout=min(30, remaining()))
        poll.raise_for_status()
        job = poll.json()
    if job.get("status") != "success":
        raise RuntimeError(f"request ended as {job.get('status')!r}")
    media = (job.get("outcome") or {}).get("media_urls") or []
    if not media:
        raise RuntimeError("success without output URLs")
    return media

generate_master(prompt, refs, "16:9") requests a 2720x1536 master; an unlisted aspect such as "4:5" raises before any paid request, which is the point: 4:5 is a crop of the 3:4 master, not a separate generation.

Every sleep and network timeout is capped by the remaining budget, so no new wait or request starts after the deadline; a response already in flight is still accepted, because that image is already paid for.

Production concerns such as idempotent retries and copying outputs to your own storage are covered in GPT Image 2.5 Sunburst editing in production.

Creatives who want to try prompts before engineering wires anything can use the GMI MCP Server, which requests images from Claude, Cursor, ChatGPT, or Codex and can report "This month's spend and which models it went to".

FAQ

Can a Seedream step and private nodes run in the same GMI Studio workflow?

A Seedream step and private nodes can share one GMI Studio workflow: the Model Library lists ByteDance Seedream nodes in its Image tab, and the same canvas holds ComfyUI native nodes and your own private logic, so generation and post-processing are one saved workflow (Workflow Canvas docs).

Favorite the inputs producers should change, and share a published version when the rest of the graph must stay fixed.

How do I reuse a private sub-pipeline across GMI Studio workflows?

In GMI Studio, save the sub-pipeline as a Blueprint: select the nodes, right-click the canvas, and choose "Save Selected as Template".

The selection becomes a "User generated subgraph blueprint" that anyone on the team can find under Blueprints in the node search and drop in as a single node (Library, Search & Blueprints).

Put the version in the Blueprint name, such as brand-look-v3.

What output size should a Seedream 5.0 Pro master use for 1080p or square formats?

Use one of the 2K-class sizes GMI Cloud lists for seedream-5.0-pro, such as 2720x1536 for 16:9 or 1760x2352 for 3:4, and derive 1920x1080, 1000x1000, and 1080x1350 in a private crop and resize step (Seedream 5.0 Pro model page).

A 4K hero comes from upscaling the 16:9 master, because the listed sizes top out at about 4.19 million pixels.

How many reference images should a Seedream 5.0 Pro request use?

A Seedream 5.0 Pro request should use 10 reference images or fewer. BytePlus's API reference states that Seedream 5.0 Pro supports up to 10 reference images, passed as a URL or an array of URLs (BytePlus image generation API).

For a larger brand kit, pick the 10 references that matter most for the generated image and list the rest in the workflow's version record.

What does Seedream 5.0 Pro cost on GMI Cloud?

On GMI Cloud MaaS, seedream-5.0-pro is $0.085 per image as of September 2026, and seedream-5.0-lite is $0.035 per image (Seedream 5.0 Pro model page, Seedream 5.0 Lite quickstart).

A campaign that generates one master per aspect family instead of one image per delivery format spends 40% less on the Seedream line.

Next step: put one campaign through a versioned Studio workflow

Open GMI Studio, build the Seedream master step and your first private Blueprint, and run a single campaign through it.

When the pipeline carries client deadlines, contact GMI Cloud sales about Studio Enterprise and dedicated GPU clusters; for backend Seedream calls, get an API key and start from the MaaS model list.

We can help map your current scripts and private nodes onto one versioned Studio workflow.