Luma

What is Luma?

Luma’s UNI-1.1 API is a reasoning model interface for teams that want to generate and modify images through an API workflow rather than prompt-by-prompt experimentation. The model interprets intent before it generates output, aiming to improve first-pass results and reduce iterations.

The API is presented as production-oriented infrastructure with two endpoints—one for reasoning and one for generation—so applications can direct an output style and composition and then produce images or edits. It also supports usage-based billing for Build and provisioned throughput for Scaling.

Key Features

• Two-endpoint workflow (reasoning + generation): One reasoning endpoint and one generation endpoint separate “thinking” from output rendering.
• Intent-directed generation with references: Up to nine references per turn for directing generation, supporting reproducible workflows.
• Structured scene logic before pixels: Capabilities such as intelligent composition, scene logic, and spatial reasoning are handled structurally before image rendering.
• Edit-oriented generation: A workflow designed to support modifying prompts by sentence-level edits while preserving existing structure “by default.”
• Multilingual and consistent rendering: Multilingual rendering and character/product consistency across scenes, poses, and markets are presented as core capabilities.
• Developer tooling: Python and JavaScript/TS SDK support (also mentioned: Go SDKs & CLI), plus an API explorer and docs for evaluation.

How to Use Luma

1. Review the UNI-1.1 API docs and API explorer to understand the reasoning/generation flow and input patterns.
2. Call the reasoning endpoint with your intent and (when needed) reference inputs to produce a guided output plan.
3. Call the generation endpoint to render the final image(s), using the structured direction from the reasoning step.
4. Start with usage-based Build plans to evaluate output quality at pay-as-you-go rates, then move to provisioned throughput if you need guaranteed latency and capacity.

Use Cases

• Brand systems for multi-page or multi-campaign creative: Generate imagery that updates across product pages and marketing campaigns in a coordinated way, including handling “messy or chained prompts” without building custom middleware.
• Production pipelines that prefer fewer retries: Use a reasoning-before-render approach to reduce the number of regeneration attempts needed to reach an acceptable first pass.
• Cross-market creative at scale: Produce outputs across different markets while maintaining character and product consistency across scenes and poses.
• Content variation with structured direction: Use up to nine references per generation to keep composition and execution aligned across multiple shots.
• Image modification workflows: Apply sentence-level edits while preserving existing structure to iterate on an image concept without starting from scratch.

FAQ

• How many endpoints does UNI-1.1 use? Luma describes two endpoints: one reasoning endpoint and one generation endpoint.

• How many references can I use per generation? The page states up to nine references per turn.

• What programming options are supported? The page mentions Python and JavaScript/TS SDKs, and also references Go SDKs & CLI.

• Is billing usage-based or capacity-based? It lists usage-based billing for Build (pay per image) and provisioned throughput for Scaling (dedicated capacity with guaranteed throughput and latency).

• Are there plans for early evaluation versus production scaling? Yes. The page separates Build (evaluate without a waitlist) from Scaling (provisioned throughput with higher rate limits and production support).

Alternatives

• Other image-generation APIs with direct text-to-image workflows: These typically combine “thinking” and rendering into a single step; UNI-1.1 differentiates by explicitly separating reasoning and generation and by supporting a reference-directed workflow.
• General-purpose multimodal generation platforms: Platforms that provide image generation plus tooling may be used for similar output tasks, but UNI-1.1 is positioned around structured reasoning and API-based integration for production pipelines.
• Prompt-automation frameworks and custom pipelines: Instead of using a two-endpoint reasoning/generation design, some teams build their own orchestration and retry logic; UNI-1.1 emphasizes reducing middleware needs for prompt chaining and edits.
• On-demand GPU image rendering services: For teams focused primarily on rendering at scale, rendering-first services may fit, while UNI-1.1 emphasizes directing and improving first-pass outcomes via reasoning before pixel generation.