# Common questions about Lamina

> 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.

Canonical page: https://uselamina.ai/faq

_Section: FAQ_

## Questions

### Basics

**Q: What is Lamina?**

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.

**Q: How does Lamina work?**

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.

### Models

**Q: Which AI models does Lamina support?**

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.

**Q: What can I generate with Lamina?**

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.

### Integration

**Q: Does Lamina support MCP?**

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.

**Q: Which languages and SDKs does Lamina support?**

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.

### Comparison

**Q: Why use Lamina instead of calling models directly?**

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.

**Q: How is Lamina different from fal.ai or Replicate?**

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.

### Brand

**Q: How does Lamina stay on-brand?**

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.

### Getting Started

**Q: How do I get started with Lamina?**

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.

### Pricing

**Q: How is Lamina priced?**

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.

### Production

**Q: Is Lamina production-ready?**

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.

### Rights

**Q: Who owns the assets Lamina generates?**

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.

## Code recipes

### Install the Lamina MCP server in Claude or Cursor

Drop one config block into your editor and get five Lamina tools as native commands.

```json
// .mcp.json — drop into Claude Desktop, Cursor, Windsurf
{
  "mcpServers": {
    "lamina": {
      "command": "npx",
      "args": ["-y", "@lamina/mcp"],
      "env": { "LAMINA_API_KEY": "sk-lm-…" }
    }
  }
}
```

### Generate a product shoot with the TypeScript SDK

Create → track → evaluate → distribute, all in one script.

1. **Install the SDK** — Run `npm install @lamina/sdk` and set LAMINA_KEY in your environment.
2. **Create the run** — Call lamina.apps.productShoot({ brief, brand, variants, ratios }) — Lamina routes the brief across the right models.
3. **Stream progress** — Iterate over lamina.jobs.stream(job.id) to receive queued → composing → rendering → done events.
4. **Evaluate against the brand kit** — Call lamina.evaluate(job.id, { rubric: 'brand' }) and keep assets with score >= 0.8.
5. **Distribute the keepers** — Call lamina.distribute(keepers, { targets: [...] }) to push to S3, Shopify, Sanity, or a webhook.

```typescript
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" },
  ],
});
```

### Generate a product shoot with the Python SDK

Same four-step flow in Python.

```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"},
])
```

### Kick off a run with cURL

Bare-metal HTTP call against the public REST API.

```bash
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 }
```

## Glossary

- **Creative app** — 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.
- **Run** — 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.
- **Brief** — 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.
- **Brand kit** — 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** — 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** — 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.

## Related

- [HTML page](https://uselamina.ai/faq)
- [Developers](https://uselamina.ai/developers) · [Pricing](https://uselamina.ai/pricing) · [Apps](https://uselamina.ai/apps)
- [llms.txt](https://uselamina.ai/llms.txt) · [llms-full.txt](https://uselamina.ai/llms-full.txt)