Lamina is a creative API that orchestrates AI image, video, and try-on models into reusable, brand-aware apps. This page answers what Lamina is, how it works, and how to ship with it.
Lamina is a creative API for AI agents and apps. You pass a brief and a brand, and Lamina returns campaign-ready assets — orchestrating image, video, and try-on models behind a single, brand-aware interface.
Every Lamina app is built on four primitives: create, track, evaluate, distribute. You call an app with a brief, Lamina routes it across the right models, scores the output against your brand kit, and delivers the keepers to S3, Drive, Sanity, Shopify, or a webhook.
Lamina routes across 15+ image, video, and try-on models from leading providers — including FLUX, Imagen, Veo, Runway, Kling, and Lamina-trained brand models. New models slot in behind the same app interface, so your code keeps working when a better model ships.
Six output types: product shoots, vertical reels, ad variants, virtual try-on, campaign banners, and brand films. Each output type is brand-aware, so colours, fonts, and product fidelity stay locked across runs.
Yes. Lamina ships an MCP server exposing five tools — create, track, evaluate, distribute, and brand_lookup — to any MCP-compatible client like Claude, Cursor, Windsurf, VS Code, Zed, or Raycast. AI agents call Lamina apps directly, with no bespoke integration code.
Lamina ships official SDKs for TypeScript and Python, plus a REST API and an MCP server. The REST API is OpenAPI 3.1 spec'd, so you can generate clients for any language.
Raw model endpoints are the easy part — orchestration and brand drift are what kill you. Lamina handles routing, prompt engineering, brand consistency, evaluation, ratios and crops, and distribution. You call apps, not models, so creative quality is reproducible and your code survives model upgrades.
fal.ai and Replicate host model endpoints; Lamina is the layer above them. Lamina ingests your brand kit, picks the best model per brief, evaluates output against brand rubrics, and distributes to your channels — generating your images, not just any images.
You upload a brand kit once — palette, voice, do/don't rules, reference assets — and Lamina grounds every prompt in it. Each run is scored against the brand rubric and off-brand assets are filtered before delivery. Reported brand-fit pass rates exceed 96% across production deployments.
Sign up for an API key, install the SDK or MCP server, and call your first app in under five minutes. The free tier includes 100 generations, with no credit card required.
Lamina is priced per generation, with volume discounts and an enterprise tier that includes dedicated capacity, SSO, and custom brand model training. See the pricing page for current per-output rates.
Yes. Lamina is in production with brands like Myntra, SHEIN, ITC, Dabur, and Remi — generating creative at scale with sub-12-second median latency. The platform offers SLA-backed availability, evaluation hooks, and audit logs for every run.
You do. Customers retain full commercial rights to assets generated through Lamina, subject to underlying model providers' terms. Lamina does not train on customer briefs, brand kits, or outputs.
Each recipe is a structured set of steps you can lift directly into your codebase.
Drop one config block into your editor and get five Lamina tools as native commands.
// .mcp.json — drop into Claude Desktop, Cursor, Windsurf
{
"mcpServers": {
"lamina": {
"command": "npx",
"args": ["-y", "@lamina/mcp"],
"env": { "LAMINA_API_KEY": "sk-lm-…" }
}
}
}Create → track → evaluate → distribute, all in one script.
Install the SDK
Run `npm install @lamina/sdk` and set LAMINA_KEY in your environment.
Create the run
Call lamina.apps.productShoot({ brief, brand, variants, ratios }) — Lamina routes the brief across the right models.
Stream progress
Iterate over lamina.jobs.stream(job.id) to receive queued → composing → rendering → done events.
Evaluate against the brand kit
Call lamina.evaluate(job.id, { rubric: 'brand' }) and keep assets with score >= 0.8.
Distribute the keepers
Call lamina.distribute(keepers, { targets: [...] }) to push to S3, Shopify, Sanity, or a webhook.
import { Lamina } from "@lamina/sdk";
const lamina = new Lamina({ apiKey: process.env.LAMINA_KEY });
const job = await lamina.apps.productShoot({
brief: "linen tee on weathered teak, north light, 35mm",
brand: "homestead",
variants: 6,
ratios: ["1:1", "4:5", "16:9"],
});
for await (const evt of lamina.jobs.stream(job.id)) {
console.log(evt.phase, evt.progress);
}
const scored = await lamina.evaluate(job.id, { rubric: "brand" });
const keepers = scored.assets.filter(a => a.score >= 0.8);
await lamina.distribute(keepers, {
targets: [
{ kind: "s3", bucket: "hs-creative", prefix: "ss26/hero/" },
{ kind: "shopify", collection: "ss26-launch" },
{ kind: "sanity", dataset: "production" },
],
});Same four-step flow in Python.
from lamina import Lamina
lamina = Lamina(api_key=os.environ["LAMINA_KEY"])
job = lamina.apps.product_shoot(
brief="linen tee on weathered teak, north light, 35mm",
brand="homestead",
variants=6,
ratios=["1:1", "4:5", "16:9"],
)
for evt in lamina.jobs.stream(job.id):
print(evt.phase, evt.progress)
scored = lamina.evaluate(job.id, rubric="brand")
keepers = [a for a in scored.assets if a.score >= 0.8]
lamina.distribute(keepers, targets=[
{"kind": "s3", "bucket": "hs-creative", "prefix": "ss26/hero/"},
{"kind": "shopify", "collection": "ss26-launch"},
{"kind": "sanity", "dataset": "production"},
])Bare-metal HTTP call against the public REST API.
curl https://api.uselamina.ai/v1/apps/product_shoot \
-H "Authorization: Bearer $LAMINA_KEY" \
-H "Content-Type: application/json" \
-d '{
"brief": "sage linen, soft north light",
"brand": "homestead",
"ratio": "16:9",
"variants": 4
}'
# → 200 OK { "job":"job_8H2K…", "eta_s": 12 }A creative app is a Lamina endpoint that turns a brief plus a brand into a finished asset (e.g., product_shoot, brand_film, ad_variants). Each app routes across the right models, applies brand context, and returns ratios and crops in one response.
A run is a single invocation of a creative app. Each run has a job ID, streamable progress events, an evaluation score, and a distribution log — so any output is reproducible and auditable.
A brief is the structured prompt passed to a Lamina app — describing the scene, constraints, ratios, and variant count. Briefs combine with the brand kit to produce on-brand creative without manual prompt engineering.
A brand kit is the collection of palette, typography, voice, do/don't rules, and reference assets that Lamina uses to ground prompts and score outputs. Upload it once and reuse it across every app.
MCP (Model Context Protocol) is the open standard that lets AI agents call external tools. Lamina ships an MCP server so any MCP-compatible client (Claude, Cursor, Windsurf, VS Code) can invoke Lamina apps as native tools.
Modality refers to the output medium — image, video, or try-on. A single Lamina app can produce multiple modalities from one brief, keeping the creative consistent across channels.
Talk to our team — we'll respond within one business day with answers tailored to your stack and use case.