Leonardo.ai

1. Introduction

1.1 Platform Overview

Leonardo.ai is a generative AI content platform developed by Leonardo Interactive Pty Ltd of Australia, aimed at creators and development teams. Unlike Midjourney's "single in-house model + community" route or Runway's "in-house film-grade models + editor" route, Leonardo's core positioning is a multi-model routed aggregation platform: it offers its own model line while also bringing third-party mainstream models under the same Token metering and the same API contract, letting users switch model backends within the same interface and the same API.

In the AI Harness six-layer capability model, Leonardo is one of the most engineering-complete platforms in this group. Its differentiator is not the models themselves but the way it explicitly exposes to callers the engineering details that platforms usually hide — "cost estimation, capacity constraints, callback deduplication, quota status, model assets". The official documentation clearly distinguishes three types of capacity constraints — rate limits, concurrency, and queue — and provides a pre-generation pricing calculator endpoint. This approach of "front-loading uncertainty as a budgetable quantity" closely aligns with the Harness definition (converting model uncertainty into engineering predictability).

1.2 Acquisition Background and Product Positioning

In 2024 Canva completed its acquisition of Leonardo — the only case in this group of "a design-tool giant acquiring a generative model platform." The meaning of this deal from a Harness perspective: Canva obtained generative capability assets that can be embedded directly into its design workflow, while Leonardo gained distribution channels and an enterprise customer pool.

In terms of product form, Leonardo serves two types of users at the same time:

• Creators: use it through the Web App's visual designer, relying on Presets, Blueprints, and Realtime Canvas to lower the barrier to entry.
• Developers and teams: use it through the production-grade REST API, relying on Webhook callbacks, concurrency controls, the pricing calculator, and exportable production code.

This "one backend, two frontends" design distinguishes it from purely consumer-facing products (such as MiaoYa Camera) and purely API products (such as BFL's official FLUX.2 API). Third-party review sites mention that the Essential tier can be included within a Canva Business subscription — medium-confidence information worth verifying directly before a business purchase.

1.3 Pricing System and Openness

Leonardo uses a dual-track system of subscription (Fast Tokens) + pay-as-you-go (PAYG API). The two have different metering systems and must be calculated separately when selecting.

Subscription tiers (official page, high confidence)

Annual discount: personal and team tiers get up to 20% off when paying annually (third-party review figure, medium confidence).

API (official page + official FAQ, high confidence)

• Pay-As-You-Go (PAYG), no monthly commitment.
• New accounts get $5 of free credit; balance never expires.
• Supports manual top-up and auto top-up (with configurable threshold and amount).
• Up to 10 concurrent generations (higher concurrency, per-model discounts, and dedicated support are negotiable on Custom plans).
• Provides an API pricing calculator endpoint for pre-generation cost estimation.

One thing worth calling out: although the Free tier is "free," the vendor clearly states that users do not hold the IP of generated assets and works are public by default — a fundamental difference from the "rights assignment" of paid tiers. Any use aimed at commercial delivery should not be built on the Free tier.

2. Glossary

2.1 AI Image General Terminology

2.2 Leonardo.ai Specific Terminology

2.3 General Terminology for Outfit and Face Swap

3. Function Overview

3.1 Capability Matrix

3.2 Model Routing and Model Training

Leonardo's model layer falls into two categories, with a substantive difference in pricing:

• First-party models: Lucid Origin, Lucid Realism, the Phoenix series, as well as FLUX Dev/Schnell, etc. These models can enjoy "unlimited relaxed generation" — running in a low-priority queue that does not count against Fast Tokens.
• Third-party models: the evaluation snapshot shows Veo 3.1, Kling 3.0, Hailuo 2.3, Seedance, Seedream 4.5, Nano Banana Pro, Flux.2 Pro, Ideogram 3.0, and others. Regardless of which subscription tier a user is on, third-party models always consume Fast Tokens. The specific version names of third-party models come from a third-party evaluation snapshot as of June 2026 and may have changed — marked [To be verified].

Model training is Leonardo's most prominent capability relative to other platforms in this group: users can train their own fine-tuned models (Personal AI Models), and once training completes, the model exists as an entity that the API can invoke directly by model ID. In Harness terms, this is equivalent to packaging the outputs of L4 (memory & state layer) — characters, styles, brand assets — into assets invocable at L2 (tools layer), a rare L2/L4 bridging design in this group.

3.3 Commercial Use and Data Policy

Official API page states clearly (very high confidence):

1. Neither input images nor generated images are used for training.
2. Input images can be actively deleted via the Delete Init Image API.
3. Generated images can be made private by setting public:false.
4. The rights, ownership, and interests in outputs are assigned by Leonardo to the user (per ToS Article 3), and are commercially usable.
5. Exception: the Free tier holds no IP and works are public.

This policy is a decisive advantage for scenarios such as e-commerce and brand marketing that need "input product images + output commercial assets." By contrast, several platforms in this group do not publicly state whether input images are used for training; purchasing decisions should defer to contract terms.

3.4 Cost Traps and Engineering Constraints

The following four points are engineering constraints that must be factored into the cost model when using Leonardo:

1. Generations blocked by content moderation still consume tokens. This means a moderation failure is not a "free retry" — batch tasks must include the block rate in their budget.
2. Third-party models always consume Fast Tokens; unlimited Relaxed generation does not apply to them.
3. Upscale runs only on the final selected image. Upscaling during the batch-draft stage would multiply costs.
4. The API concurrency cap is 10. Throughput planning should design queues against this hard cap; anything beyond requires negotiating a Custom plan.

The two-stage workflow recommended in the official developer guide: first use low-cost models (e.g., LCM preview) to batch-test directions, then refine and upscale the selected one. This is one of the few "cost-aware orchestration patterns" in this group's documentation that came proactively from the platform itself.

4. Platform Architecture

图 4-1｜Leonardo.ai 多模型路由聚合架构

数据来源：基于本文分析绘制的示意图。

4.1 Multi-Model Routing Aggregation Architecture

Leonardo's architecture can be understood as a layer of "unified contract + heterogeneous backends":

[Web App 可视化设计器]        [生产级 REST API]
            \                      /
             \                    /
        [统一 Token 计价 / 统一 API 契约]
                     |
        +------------+------------+
        |                         |
  [第一方模型]              [第三方模型路由]
  Lucid / Phoenix /          Veo / Kling / Hailuo /
  FLUX Dev·Schnell          Seedance / Seedream /
  （可 Relaxed 不限量）      Nano Banana Pro / Flux.2 Pro
        |                         |
        +------------+------------+
                     |
        [训练服务]  [放大/去背景]  [Webhook 回调]

The key engineering point: billing and interfaces are unified at the aggregation layer, while quality and cost diverge at the backend layer. Callers do not need to write a separate SDK for each backend, but they must write a separate cost strategy for each backend.

4.2 Production-Grade API Contract

The engineering completeness of the official API ranks near the top of this group, as shown by:

• Exportable production code: configurations in the Web App can be exported directly as runnable code, shortening the path from "tuning to find results" to "connecting to production."
• Webhook callbacks: proactive notification when an async task completes, requiring idempotent deduplication by generationId while keeping polling reconciliation as a fallback — a clear distributed-systems best-practice guide.
• Pricing calculator endpoint: estimates cost before generation, turning "budget" into a first-class parameter that can be queried before execution.
• Three types of capacity constraints explicitly documented: rate limits, concurrency, and queue are each explained, along with retry recommendations using exponential backoff with jitter.

4.3 Relationship with Canva

Canva acquired Leonardo in 2024. The verifiable fact: third-party reviews mention that the Essential tier is included in a Canva Business subscription (medium confidence, worth rechecking). At the architecture level, this acquisition means Leonardo's generation capabilities may be embedded into Canva's templates and design workflows, extending Harness's L3 (orchestration) from "Leonardo-internal Blueprints" to "the entire design production pipeline." However, no official account of the depth and current status of this integration was found — marked [To be verified].

5. Harness Design

5.1 Six-Layer Capability Overview

5.2 L1 Context Engineering Layer

Leonardo's context engineering has two traits:

First, context asset-ization. Most platforms leave "a tuned set of prompts and parameters" in the user's notepad; Leonardo solidifies them into Presets and Personal AI Models — the former being parameter combinations and the latter weight-level assets. The Ultimate tier allows 50 personal models, meaning a team can simultaneously maintain 50 "character/style/product-line" context entities and invoke them precisely by model ID in the API. Under the Harness semantics, this is addressable context.

Second, cost-budget front-loading. The Pricing Calculator endpoint lets you query the expected consumption before a generation action happens. This extends the "context budget" from the prompt-length dimension into the money dimension — callers can first ask "how much will this batch cost" and then decide whether to proceed.

5.3 L2 Tools & Execution Layer

The toolset is: generation, editing, video, upscale, background removal, training, Webhook. Tool forms include both Web-side buttons and REST endpoints.

The key difference from other platforms lies in the training API: self-trained fine-tuned models are isomorphic to official models in the API — both are invoked by model ID. This means "training a brand-specific model" is no longer an offline activity but a step orchestrable inside an automated pipeline. It is the clearest case in this group of elevating an L4 output directly into an L2 tool.

5.4 L3 Orchestration & Control Layer

Leonardo's orchestration capability consists of three parts:

1. Blueprints: solidify a multi-step generation process into a repeatable template; Free tier is limited to 1 concurrency and a queue of 5.
2. API-side orchestration: the caller implements the workflow itself, while the platform provides capacity constraints and retry semantics.
3. Production-grade orchestration guidance: the official docs clearly distinguish rate limits / concurrency / queue, and give concrete recommendations such as exponential backoff with jitter, Webhook idempotent deduplication, and exposing queue state to users.

It is worth noting that Leonardo's L3 is "complete guidance, external engine" — it has no visual node graph like ComfyUI, nor Runway's Agentic collaborator, but it spells out all the semantics needed to call it correctly in a distributed system. For engineering teams, this is often more practical than a black-box orchestrator.

5.5 L4 Memory & State Layer

L4 on this platform has four recognizable state entities:

This design makes "team-level state" a first-class citizen: a Team tier is not simply "several more accounts" but a shared Token pool and shared asset space. This differs substantively from a model where each seat is billed separately and assets are invisible.

5.6 L5 Evaluation & Observability Layer

Leonardo's L5 is an observability system centered on cost, not on quality:

• Pricing Calculator endpoint: pre-generation estimation.
• Per-generation cost metadata recording: post-generation accounting.
• Per-user budget: account-level cap.
• draft-vs-final switching: the officially recommended two-stage workflow, essentially a "cheap exploration + expensive convergence" evaluation strategy.

No official public Eval Set, Golden Dataset, or image-quality regression set was found. In other words, Leonardo observes "how much was spent," not "how close the drawing is" — the latter still done by humans.

5.7 L6 Governance & Security Layer

This is Leonardo's strongest area in this group, and it is all explicitly stated by the vendor (very high confidence):

• Neither input images nor generated images are used for training.
• Provides the Delete Init Image API so input images can be actively deleted.
• Generated images can be made private with public:false.
• ToS Article 3: rights, ownership, and interests in outputs are assigned to the user.
• Free-tier exception: IP belongs to Leonardo, works are public.
• Content moderation blocks generation, but it still consumes tokens (governance cost borne by the user, to be avoided by design).

A compliance gap worth flagging: Leonardo publicly states data-usage and rights-ownership policy, but no explicit/implicit labeling implementation for China's Measures for the Labeling of AI-Generated and Synthetic Content was found. When distributing to mainland China, this part must be filled in by the caller (see section 7.4).

5.8 Maturity Assessment

Leonardo belongs to the third-generation Harness form of "outsourced model layer + in-house engineering layer." Its six-layer maturity can be summarized as: L1 strong (context asset-ization), L2 strong (including the training API), L3 strong (capacity semantics complete), L4 strong (four state entities + team pool), L5 medium-strong (cost observability complete, quality observability missing), L6 strong (data policy explicit).

Relative position within this group: it is far more engineered than Midjourney (whose L2/L3/L5 are all un-engineered); versus the ComfyUI ecosystem, it sacrifices orchestration freedom (no node graph, no version-controlled workflow artifacts) in exchange for an out-of-the-box production contract; versus Runway, its brand-asset abstraction (Personal AI Models) leans toward "model assets" rather than "Brand Kits."

6. Real-World Cases

6.1 Official Customer List Search Results

Brands appearing in the official "trusted-by" showcase include Coca-Cola, Ducati, NVIDIA, and Springbok (relayed from third-party review sites, medium confidence). Merchant case studies with quantified performance data: none found.

Per this group's unified writing discipline, this section cannot be replaced with vague phrasing such as "widely used for advertising creatives, e-commerce hero images, and game assets" — because there is no verifiable quantified data to support it. Third-party review sites' descriptions of usage do not constitute case studies.

6.2 Verifiable Integration and Scale Facts

The following are facts verifiable against the vendor's own claims — "scale metrics" rather than "customer outcomes":

6.3 An Arithmetic Example of Credit Planning

Since the vendor has not published a unified conversion table for "how many Fast Tokens a single generation consumes" (that consumption varies by model, resolution, and output count — marked [To be verified]), an exact "cost per image" cannot be given. But it is possible to derive an upper-bound arithmetic for credit planning based on official tier data:

• Essential tier: 8,500 monthly, with a Rollover Bank cap of 25,500 — exactly 3 months of unused credits as the accumulation cap. This means up to about 3 months of "zero consumption + rollover" can be sustained; from the 4th month onward, the excess is forfeited.
• If a batch task needs to run in a given month, consumption can be reduced for 3 months in advance to "build the pool" — this is the core value of the Rollover Bank relative to a "reset at month-end" model.
• Team Growth: 180,000 shared credits ÷ 3 seats = 60,000 per person, on par with the individual Ultimate tier, but credits can be dynamically reallocated across seats, which is friendlier to teams with unbalanced workloads.

The above arithmetic is based solely on officially published tier numbers and involves no speculation about per-use unit pricing.

7. Summary

7.1 Advantages

1. Complete engineering contract: three types of capacity constraints, Webhook idempotency, backoff retries, and the pricing calculator are all officially documented, minimizing hidden costs when integrating into production systems.
2. Most explicit data policy: inputs/outputs not used for training, input images deletable, outputs can be private, and rights are assigned — decisive terms for e-commerce and brand customers.
3. Model asset-ization: Personal AI Models turn training outputs into assets invocable by ID, achieving the L4-to-L2 bridge.
4. Unified contract across multiple backends: one SDK switches across 80+ models, avoiding a separate integration codebase per vendor.
5. Team-level state design: a shared Token pool and shared asset space, rather than simple multi-account billing.

7.2 Limitations and Applicability Boundaries

1. No visual orchestration: lacks ComfyUI-style node graphs and workflow version control; complex multi-stage processes must be implemented by the caller.
2. Missing quality observability: observes cost but not quality, with no official Eval Set or regression set.
3. Moderation blocks are still billed: governance failures are paid for by the user; batch tasks need to reserve a block-rate budget.
4. Third-party models do not enjoy Relaxed: the cost advantage only covers first-party models.
5. Third-party model list may be outdated: the version names found come from a June 2026 snapshot and need rechecking.
6. Mainland China labeling compliance unclear: no explicit/implicit labeling implementation for the Measures was found.

7.3 Selection Recommendations

7.4 Compliance Notes

When providing services to mainland China, the following compliance anchors must be incorporated into the design:

• The Measures for the Labeling of AI-Generated and Synthetic Content (CAC Circular [2025] No. 2) came into effect on 2025-09-01. Article 4 requires that when a service provider offers functions such as downloading, copying, and exporting generated/perceptible-synthetic content, it shall ensure the file contains an explicit label that meets requirements; Article 5 requires shall adding an implicit label in the file metadata (including attributes of the generated content, the service provider's name or code, a content number, etc.), and encourages adding an implicit label in the form of a digital watermark; Article 6 requires distribution platforms to verify the metadata implicit label and handle it in three tiers; Article 10 is the red line: no organization or individual may maliciously delete, alter, forge, or conceal labels, nor may provide tools or services enabling others to do so.
• If using Leonardo's outfit/face-swap capabilities or self-trained portrait models, the Civil Code of the People's Republic of China also applies: Article 1018 (a portrait is "an external image that can be recognized") and Article 1019 (one may not infringe portrait rights by means such as forgery through information technology; one may not create, use, or publicly disclose a portrait without consent). The fair-use situations enumerated in Article 1020 do not include commercial face swapping.
• A judgment that took effect in March 2026 from the Beijing Internet Court established two key rules: recognizability is the core standard for determining infringement (an AI-swapped image need not be identical to the original portrait; if the general public can recognize it, it constitutes use of a specific natural person's portrait); and burden-of-proof reversal (a defendant claiming an "accidental AI resemblance" must reproduce the creation process; failure to reproduce it leads to adverse consequences of failing to prove the claim). The judgment also clarified that "technological neutrality" is not a ground for exemption from liability.
• Industry warning: on 2026-04-28, Jimeng AI — also a subject of this group's research — was lawfully investigated and sanctioned by the cyberspace administration for failing to effectively implement the labeling requirements for AI-generated and synthetic content. This shows that "model-capability compliance" is not equivalent to "product-distribution compliance"; the export and distribution stages are where regulatory scrutiny lands.

Information Gap Statement

1. Leonardo.ai platform version number: no unified version-number statement found; models iterate independently per backend — marked [To be verified].
2. The conversion table for Fast Tokens consumed per generation: the vendor has not published unified conversion rules — marked [To be verified].
3. Third-party model version names (Veo 3.1, Kling 3.0, Hailuo 2.3, Seedream 4.5, Flux.2 Pro, Ideogram 3.0, etc.): from a third-party evaluation snapshot as of June 2026, may have changed — marked [To be verified].
4. The specific bundling with Canva Business after the Canva acquisition: only third-party reviews mention that the Essential tier is included in Canva Business — marked [To be verified].
5. Official customer cases and quantified performance data: none found; honestly marked as "not found."
6. Explicit/implicit labeling implementation details for the Measures: no official explanation found — marked [To be filled].
7. Official boundary policy for outfit/face-swap capabilities: no separately published terms found — marked [To be filled].
8. Specific annual-discount ratio: third-party sources say up to 20% off — marked [To be verified].

8. References

1. Leonardo.Ai Pricing (official page) — Leonardo Interactive. https://www.leonardo.ai/pricing
2. Leonardo.Ai API (official page, including commercial-use and data-usage FAQ) — Leonardo Interactive. https://www.leonardo.ai/api
3. Pricing & Plans FAQs (official FAQ, including PAYG migration notes) — Leonardo Interactive. https://docs.leonardo.ai/docs/pricing-and-plans-faq
4. Leonardo API Complete Developer Guide (2026 update) — Agents APIs (third-party, medium confidence). https://agentsapis.com/leonardo-api/
5. Leonardo.AI Pricing 2026 (incl. Canva acquisition and model lineup) — eesel.ai (third-party, medium confidence). https://www.eesel.ai/blog/leonardo-ai-pricing
6. Full text of the Measures for the Labeling of AI-Generated and Synthetic Content — Cyberspace Administration of China, 2025-03-14. https://www.cac.gov.cn/2025-03/14/c_1743654684782215.htm
7. Interpretation of the Measures for the Labeling of AI-Generated and Synthetic Content — Gov.cn / Xinhua, 2025-03-16. https://www.gov.cn/zhengce/202503/content_7014281.htm
8. "From September 1, AI-generated and synthetic content must be labeled" — CCTV, 2025-03-15. https://big5.cctv.com/gate/big5/news.cctv.cn/2025/03/15/ARTI36OOL0hP5mpvU5cDgo4L250315.shtml
9. "Technology is not an 'escape shield' for infringement; the court found AI 'face-theft' this way" — Economic Information Daily / Xinhua, 2026-04-17. http://dz.jjckb.cn/www/pages/webpage2009/html/2026-04/17/content_115180.htm
10. "Case review: short-drama character AI face-swap 'eerily resembling' a famous actor — accidental 'look-alike' or intentional infringement?" — contributed by the Beijing Internet Court, The Paper. https://www.thepaper.cn/newsDetail_forward_32799628