modellix

---
name: modellix
description: Integrate Modellix's unified API for AI image and video generation into applications. Use this skill whenever the user wants to generate images from text, create videos from text or images, edit images, do virtual try-on, or call any Modellix model API. Also trigger when the user mentions Modellix, model-as-a-service for media generation, or needs to work with providers like Qwen, Wan, Seedream, Seedance, Kling, Hailuo, or MiniMax through a unified API.
metadata:
    mintlify-proj: modellix
    version: "2.0"
    primaryEnv: MODELLIX_API_KEY
    requiredEnv:
      - MODELLIX_API_KEY
---

# Modellix Skill

Modellix is a Model-as-a-Service (MaaS) platform with async image/video generation APIs. The invariant flow is: submit task -> get `task_id` -> poll until `success` or `failed`.

## Official Docs

- AI Onboarding (agent quick start): https://docs.modellix.ai/get-started.md
- API: https://docs.modellix.ai/ways-to-use/api.md
- CLI: https://docs.modellix.ai/ways-to-use/cli.md
- Full Models Docs Index: https://docs.modellix.ai/llms.txt

## Execution Policy (CLI-first)

Always choose execution path in this order:

1. Use **CLI** when `modellix-cli` is available and authenticated.
2. Fall back to **REST** when CLI is unavailable, unsuitable, or missing capability.
3. Prefer machine-readable outputs (`--json`) in CLI flows.

## Preflight and Deterministic Execution

Use bundled scripts before ad-hoc commands:

1. `scripts/preflight.py`
   - Validates CLI availability and API key presence.
   - Returns recommended mode (`cli` or `rest`).
2. `scripts/invoke_and_poll.py`
   - Executes CLI-first with REST fallback support.
   - Handles exponential backoff polling and retryable submit errors.
   - Emits normalized JSON result output.

Quick commands:

```powershell
python scripts/preflight.py --json
python scripts/invoke_and_poll.py --model-slug bytedance/seedream-4.5-t2i --body '{"prompt":"A cinematic portrait of a fox in a misty forest at sunrise"}'
```

## Core Workflow

### 1) Obtain API key

- Create key in [Modellix Console](https://modellix.ai/console/api-key)
- Save immediately (shown once)
- Store as `MODELLIX_API_KEY`

### 2) Select model

Read `references/REFERENCE.md` to find model docs and parameters.

### 3) Run invocation and poll

- Preferred: `scripts/invoke_and_poll.py`
- Manual CLI flow: `references/cli-playbook.md`
- Manual REST flow: `references/rest-playbook.md`

### 4) Consume resources

Output media URLs are under `result.resources`. Persist assets promptly; results expire in 24 hours.

## Progressive Reference Routing

Read only what the task needs:

- `references/cli-playbook.md`
  - CLI install/auth/command flow and retry guidance
- `references/rest-playbook.md`
  - REST endpoints, headers, status model, retry policy
- `references/capability-matrix.md`
  - CLI command <-> REST endpoint mapping and fallback rules

## Bundled Assets

- Output schema:
  - `assets/output/task-result.schema.json`

## Credential and Data Egress

- Required credential: `MODELLIX_API_KEY` (this skill does not require any other secret).
- Network egress: sends requests to `https://api.modellix.ai`.
- User payload handling: prompts and user-provided inputs (including media URLs or file-derived content) may be sent to Modellix endpoints during invocation.
- Result handling: generated resource URLs come from Modellix response payloads and should be downloaded before expiry (about 24 hours).

## Error/Retry Policy

| Code | Action |
|------|--------|
| 400 | Do not retry. Fix parameters or request body format. |
| 401 | Do not retry. Verify API key. |
| 402 | Do not retry. Insufficient balance. |
| 404 | Do not retry. Verify task_id or model-slug. |
| 429 | Retry with exponential backoff. |
| 500/503 | Retry with exponential backoff (max 3 times). |

## Verification Checklist

- [ ] Preflight executed and mode selected (`cli` or `rest`)
- [ ] API key configured (`MODELLIX_API_KEY` or CLI `--api-key`)
- [ ] Model parameters verified against model doc from `references/REFERENCE.md`
- [ ] Task submit returns `task_id` with success code
- [ ] Polling handles `pending`, `processing`, `success`, `failed`
- [ ] Retry behavior implemented for `429/500/503`
- [ ] Result URLs persisted before 24-hour expiration
- [ ] REST fallback validated when CLI path is unavailable

FILE:skill.json
{
  "name": "modellix",
  "version": "2.0.0",
  "description": "Integrate Modellix unified API/CLI for async image and video generation.",
  "primaryEnv": "MODELLIX_API_KEY",
  "env": [
    {
      "name": "MODELLIX_API_KEY",
      "description": "API key for Modellix CLI and REST API calls.",
      "required": true
    }
  ]
}

FILE:assets/output/task-result.schema.json
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "https://modellix.ai/schemas/task-result.schema.json",
  "title": "ModellixTaskResult",
  "type": "object",
  "additionalProperties": false,
  "required": ["mode_used", "task_id", "status", "resources", "raw"],
  "properties": {
    "mode_used": {
      "type": "string",
      "enum": ["cli", "rest"]
    },
    "task_id": {
      "type": "string"
    },
    "status": {
      "type": "string",
      "enum": ["pending", "processing", "success", "failed"]
    },
    "model_id": {
      "type": ["string", "null"]
    },
    "resources": {
      "type": "array",
      "items": {
        "type": "object",
        "additionalProperties": true,
        "required": ["url", "type"],
        "properties": {
          "url": { "type": "string" },
          "type": { "type": "string" },
          "width": { "type": ["number", "null"] },
          "height": { "type": ["number", "null"] },
          "format": { "type": ["string", "null"] },
          "role": { "type": ["string", "null"] }
        }
      }
    },
    "raw": {
      "type": "object",
      "additionalProperties": true,
      "required": ["submit", "poll"],
      "properties": {
        "submit": { "type": "object", "additionalProperties": true },
        "poll": { "type": "object", "additionalProperties": true }
      }
    }
  }
}

FILE:scripts/invoke_and_poll.py
#!/usr/bin/env python3
"""
Submit and poll a Modellix async task using CLI-first with REST fallback.

Examples:
  python scripts/invoke_and_poll.py \
    --model-slug bytedance/seedream-4.5-t2i \
    --body '{"prompt":"A cinematic portrait of a fox in a misty forest at sunrise"}'
"""

from __future__ import annotations

import argparse
import json
import os
import shutil
import subprocess
import sys
import time
import urllib.error
import urllib.request
from typing import Any, Dict, Optional, Tuple

BASE_URL = "https://api.modellix.ai/api/v1"
RETRYABLE_STATUS = {429, 500, 503}
MAX_RETRIES = 3


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Invoke Modellix and poll result.")
    parser.add_argument(
        "--model-slug",
        required=True,
        help="Model slug in provider/model format, e.g. bytedance/seedream-4.5-t2i",
    )
    parser.add_argument("--body", help="Inline JSON request body")
    parser.add_argument("--body-file", help="Path to JSON request body file")
    parser.add_argument("--api-key", help="API key override; defaults to MODELLIX_API_KEY")
    parser.add_argument("--mode", choices=["auto", "cli", "rest"], default="auto")
    parser.add_argument("--initial-wait", type=float, default=1.0)
    parser.add_argument("--max-wait", type=float, default=10.0)
    parser.add_argument("--timeout-seconds", type=int, default=180)
    return parser.parse_args()


def load_body(args: argparse.Namespace) -> Dict[str, Any]:
    if bool(args.body) == bool(args.body_file):
        raise ValueError("Provide exactly one of --body or --body-file.")
    if args.body_file:
        with open(args.body_file, "r", encoding="utf-8") as fh:
            return json.load(fh)
    return json.loads(args.body)


def get_api_key(args: argparse.Namespace) -> str:
    key = args.api_key or os.getenv("MODELLIX_API_KEY")
    if not key:
        raise RuntimeError("Missing API key. Set MODELLIX_API_KEY or pass --api-key.")
    return key


def parse_model_slug(model_slug: str) -> Tuple[str, str]:
    if "/" not in model_slug:
        raise ValueError("Invalid --model-slug. Expected format: <provider>/<model_id>.")
    provider, model_id = model_slug.split("/", 1)
    provider = provider.strip()
    model_id = model_id.strip()
    if not provider or not model_id:
        raise ValueError("Invalid --model-slug. Provider and model_id must be non-empty.")
    return provider, model_id


def run_cli(args: argparse.Namespace) -> Dict[str, Any]:
    cmd = [
        "modellix-cli",
        "model",
        "invoke",
        "--model-slug",
        args.model_slug,
    ]
    if args.body_file:
        cmd.extend(["--body-file", args.body_file])
    else:
        cmd.extend(["--body", args.body])

    if args.api_key:
        cmd.extend(["--api-key", args.api_key])

    proc = subprocess.run(cmd, check=False, capture_output=True, text=True)
    if proc.returncode != 0:
        raise RuntimeError(f"CLI invoke failed: {proc.stderr.strip() or proc.stdout.strip()}")
    return json.loads(proc.stdout)


def http_request(url: str, method: str, api_key: str, body: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json",
    }
    data: Optional[bytes] = None
    if body is not None:
        data = json.dumps(body).encode("utf-8")

    req = urllib.request.Request(url=url, method=method, headers=headers, data=data)
    try:
        with urllib.request.urlopen(req, timeout=30) as resp:
            text = resp.read().decode("utf-8")
            return json.loads(text) if text else {}
    except urllib.error.HTTPError as exc:
        payload = exc.read().decode("utf-8")
        try:
            parsed = json.loads(payload)
        except json.JSONDecodeError:
            parsed = {"code": exc.code, "message": payload}
        parsed.setdefault("code", exc.code)
        return parsed


def run_rest_submit(args: argparse.Namespace, body: Dict[str, Any], api_key: str) -> Dict[str, Any]:
    provider, model_id = parse_model_slug(args.model_slug)
    url = f"{BASE_URL}/{provider}/{model_id}/async"
    attempts = 0
    wait = args.initial_wait
    while True:
        result = http_request(url=url, method="POST", api_key=api_key, body=body)
        code = int(result.get("code", 500))
        if code == 0:
            return result
        if code not in RETRYABLE_STATUS or attempts >= MAX_RETRIES:
            raise RuntimeError(f"REST invoke failed: {json.dumps(result, ensure_ascii=False)}")
        attempts += 1
        time.sleep(wait)
        wait = min(wait * 2, args.max_wait)


def run_rest_poll(task_id: str, api_key: str, poll_url: Optional[str] = None) -> Dict[str, Any]:
    url = poll_url or f"{BASE_URL}/tasks/{task_id}"
    return http_request(url=url, method="GET", api_key=api_key)


def pick_mode(args: argparse.Namespace, api_key: str) -> str:
    if args.mode in {"cli", "rest"}:
        return args.mode
    has_cli = shutil.which("modellix-cli") is not None
    return "cli" if has_cli and api_key else "rest"


def extract_task_id(payload: Dict[str, Any]) -> Tuple[str, Optional[str]]:
    data = payload.get("data", {})
    task_id = data.get("task_id")
    if not task_id:
        raise RuntimeError(f"Missing task_id in response: {json.dumps(payload, ensure_ascii=False)}")
    poll_url = (data.get("get_result") or {}).get("url")
    return str(task_id), poll_url


def normalize_output(mode_used: str, submit_payload: Dict[str, Any], poll_payload: Dict[str, Any]) -> Dict[str, Any]:
    data = poll_payload.get("data", {})
    result = data.get("result", {})
    resources = result.get("resources", [])
    return {
        "mode_used": mode_used,
        "task_id": data.get("task_id") or submit_payload.get("data", {}).get("task_id"),
        "status": data.get("status"),
        "model_id": data.get("model_id") or submit_payload.get("data", {}).get("model_id"),
        "resources": resources,
        "raw": {
            "submit": submit_payload,
            "poll": poll_payload,
        },
    }


def main() -> int:
    args = parse_args()
    body = load_body(args)
    api_key = get_api_key(args)
    mode = pick_mode(args, api_key)

    submit_payload: Dict[str, Any]
    if mode == "cli":
        submit_payload = run_cli(args)
    else:
        submit_payload = run_rest_submit(args, body, api_key)

    task_id, poll_url = extract_task_id(submit_payload)

    started = time.time()
    wait = args.initial_wait
    poll_payload: Dict[str, Any] = {}
    while True:
        if time.time() - started > args.timeout_seconds:
            raise TimeoutError("Polling timed out before task reached success/failed.")
        time.sleep(wait)
        if mode == "cli":
            poll_cmd = ["modellix-cli", "task", "get", task_id]
            if args.api_key:
                poll_cmd.extend(["--api-key", args.api_key])
            proc = subprocess.run(poll_cmd, check=False, capture_output=True, text=True)
            if proc.returncode != 0:
                raise RuntimeError(f"CLI poll failed: {proc.stderr.strip() or proc.stdout.strip()}")
            poll_payload = json.loads(proc.stdout)
        else:
            poll_payload = run_rest_poll(task_id, api_key, poll_url)

        status = str(poll_payload.get("data", {}).get("status", "")).lower()
        if status in {"success", "failed"}:
            break
        wait = min(wait * 2, args.max_wait)

    print(json.dumps(normalize_output(mode, submit_payload, poll_payload), ensure_ascii=False, indent=2))
    return 0


if __name__ == "__main__":
    try:
        raise SystemExit(main())
    except Exception as exc:  # noqa: BLE001 - simple script error surface
        print(f"ERROR: {exc}", file=sys.stderr)
        raise SystemExit(1)

FILE:scripts/clean_build_artifacts.py
#!/usr/bin/env python3
"""
Remove local Python build artifacts before publishing the skill package.
"""

from __future__ import annotations

from pathlib import Path
import shutil


def main() -> int:
    root = Path(__file__).resolve().parents[1]
    removed = 0

    for cache_dir in root.rglob("__pycache__"):
        if cache_dir.is_dir():
            file_count = sum(1 for p in cache_dir.rglob("*") if p.is_file())
            shutil.rmtree(cache_dir, ignore_errors=True)
            removed += file_count
            removed += 1

    for pyc in root.rglob("*.pyc"):
        pyc.unlink(missing_ok=True)
        removed += 1

    print(f"cleaned_artifacts={removed}")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

FILE:scripts/README.md
# Scripts

These scripts make the Modellix skill executable instead of documentation-only.

## preflight.py

Windows-first environment check for CLI-first routing.

Usage:

```powershell
python scripts/preflight.py
python scripts/preflight.py --json
```

Checks:
- `modellix-cli` availability
- `MODELLIX_API_KEY` availability
- Recommended mode (`cli` or `rest`)

## invoke_and_poll.py

Submit a task and poll until `success` or `failed` with exponential backoff.

Usage:

```bash
python scripts/invoke_and_poll.py \
  --model-slug bytedance/seedream-4.5-t2i \
  --body '{"prompt":"A cinematic portrait of a fox in a misty forest at sunrise"}'
```

Key behavior:
- Mode `auto` (default): use CLI when available, otherwise REST
- Retry submit on `429/500/503` (up to 3 retries)
- Normalize output with task metadata and resources
- `--model-slug` is required in `provider/model` format

FILE:scripts/preflight.py
#!/usr/bin/env python3
"""
Cross-platform preflight check for CLI-first routing.
"""

from __future__ import annotations

import argparse
import json
import os
import shutil


def main() -> int:
    parser = argparse.ArgumentParser(description="Check Modellix CLI and API key readiness.")
    parser.add_argument("--json", action="store_true", help="Emit JSON output")
    args = parser.parse_args()

    notes: list[str] = []
    cli_available = shutil.which("modellix-cli") is not None
    if not cli_available:
        notes.append("modellix-cli not found. Install with: npm install -g modellix-cli")

    api_key_available = bool((os.getenv("MODELLIX_API_KEY") or "").strip())
    if not api_key_available:
        notes.append("MODELLIX_API_KEY is not set. Configure it or pass --api-key per command.")

    recommended_mode = "rest"
    if cli_available and api_key_available:
        recommended_mode = "cli"
        notes.append("CLI path is available. Use modellix-cli as primary path.")
    elif api_key_available:
        notes.append("REST fallback is available because API key exists.")
    else:
        notes.append("Neither CLI-auth nor REST-auth is ready. Configure API key first.")

    result = {
        "cli_available": cli_available,
        "api_key_available": api_key_available,
        "recommended_mode": recommended_mode,
        "notes": notes,
    }

    if args.json:
        print(json.dumps(result, ensure_ascii=False, indent=2))
    else:
        print(f"cli_available      : {result['cli_available']}")
        print(f"api_key_available  : {result['api_key_available']}")
        print(f"recommended_mode   : {result['recommended_mode']}")
        if notes:
            print("notes:")
            for note in notes:
                print(f"- {note}")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

FILE:references/rest-playbook.md
# REST Playbook

Use this reference when CLI is unavailable, unsuitable, or missing required capability.

## Base URL

`https://api.modellix.ai/api/v1`

## Auth

Header:

```http
Authorization: Bearer <MODELLIX_API_KEY>
```

## Core Endpoint Flow

1) Submit async task:

```http
POST /{provider}/{model_id}/async
```

2) Poll task:

```http
GET /tasks/{task_id}
```

## cURL Example

Submit:

```bash
curl -X POST "https://api.modellix.ai/api/v1/alibaba/qwen-image-plus/async" \
  -H "Authorization: Bearer $MODELLIX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"prompt":"A cute cat playing in a garden on a sunny day"}'
```

The submit response includes `get_result` with the polling endpoint:

```json
{
  "code": 0,
  "message": "success",
  "data": {
    "status": "pending",
    "task_id": "task-abc123",
    "model_id": "model-123",
    "get_result": {
      "method": "GET",
      "url": "https://api.modellix.ai/api/v1/tasks/task-abc123"
    }
  }
}
```

Poll:

```bash
curl -X GET "https://api.modellix.ai/api/v1/tasks/<task_id>" \
  -H "Authorization: Bearer $MODELLIX_API_KEY"
```

## Status Model

- `pending`: queued, not yet started
- `processing`: actively generating, continue polling
- `success`: read output from `data.result.resources`
- `failed`: inspect error payload

## Retry Policy

Retryable:
- `429` (too many requests)
- `500` (internal server error)
- `503` (service unavailable)

Strategy:
- Exponential backoff (`1s -> 2s -> 4s`)
- Max 3 retries for `500`/`503`
- Respect `X-RateLimit-Reset` for `429` when available

Non-retryable:
- `400`, `401`, `402`, `404`

## Notes

- Task outputs expire after 24 hours.
- Parameter shapes vary per model; always verify model docs before invocation.

FILE:references/REFERENCE.md
# Modellix

## Docs

- [Qwen Image](https://docs.modellix.ai/alibaba/qwen-image.md): Qwen-image excels in text rendering, especially Chinese. qwen-image-plus and qwen-image share the same capabilities, but qwen-image-plus is more cost-effective.
- [Qwen Image Edit](https://docs.modellix.ai/alibaba/qwen-image-edit.md): Qwen-image-edit supports bilingual text editing, color adjustment, style transfer, object addition/removal, and other complex image editing operations.
- [Qwen Image Edit Plus](https://docs.modellix.ai/alibaba/qwen-image-edit-plus.md): Qwen-image-edit supports bilingual text editing, color adjustment, style transfer, object addition/removal, and other complex image editing operations.
- [Qwen Image Edit Plus 2025-10-30](https://docs.modellix.ai/alibaba/qwen-image-edit-plus-2025-10-30.md): Qwen-image-edit supports bilingual text editing, color adjustment, style transfer, object addition/removal, and other complex image editing operations.
- [Qwen Image Edit Plus 2025-12-15](https://docs.modellix.ai/alibaba/qwen-image-edit-plus-2025-12-15.md): Qwen-image-edit supports bilingual text editing, color adjustment, style transfer, object addition/removal, and other complex image editing operations.
- [Qwen Image Plus](https://docs.modellix.ai/alibaba/qwen-image-plus.md): Qwen-image excels in text rendering, especially Chinese. qwen-image-plus and qwen-image share the same capabilities, but qwen-image-plus is more cost-effective.
- [Wan 2.2 I2V Flash](https://docs.modellix.ai/alibaba/wan-2-2-i2v-flash.md): Wan image-to-video model generates videos from prompts and images. Wan 2.2 Flash offers fast generation, accurate instructions, camera control, and improved stability.
- [Wan 2.2 I2V Plus](https://docs.modellix.ai/alibaba/wan-2-2-i2v-plus.md): Wan image-to-video model generates videos from prompts and images. Wan 2.2 Plus improves instruction accuracy, camera control, visual consistency, and content richness.
- [Wan 2.2 KF2V Flash](https://docs.modellix.ai/alibaba/wan-2-2-kf2v-flash.md): The Wan First-and-Last-Frame Video Generation Model: simply provide the first and last frame images, and it can generate a smooth, fluid dynamic video based on the prompt.
- [Wan 2.2 T2I Flash](https://docs.modellix.ai/alibaba/wan-2-2-t2i-flash.md): The Wan text-to-image model generates beautiful images from text. The wan2.2-t2i-flash has been comprehensively upgraded in creativity, stability, and writing texture.
- [Wan 2.2 T2I Plus](https://docs.modellix.ai/alibaba/wan-2-2-t2i-plus.md): The Wan text-to-image model generates beautiful images from text. The wan2.2-t2i-plus has been comprehensively upgraded in creativity, stability, and writing texture.
- [Wan 2.2 T2V Plus](https://docs.modellix.ai/alibaba/wan-2-2-t2v-plus.md): Wan text-to-video model generates videos from text with rich artistic styles. Wan 2.2 improves instruction accuracy, motion smoothness, and detail richness.
- [Wan 2.5 I2I Preview](https://docs.modellix.ai/alibaba/wan-2-5-i2i-preview.md): Wan 2.5 image-to-image model supports text, single or multiple image input for subject-consistent editing and multi-image fusion creation.
- [Wan 2.5 T2I Preview](https://docs.modellix.ai/alibaba/wan-2-5-t2i-preview.md): Wan text-to-image model generates images from text. wan2.5-t2i-preview allows free size selection within total pixel area and aspect ratio constraints.
- [Wan 2.5 T2V Preview](https://docs.modellix.ai/alibaba/wan-2-5-t2v-preview.md): Wan text-to-video model generates videos from text with rich artistic styles and cinematic quality. Wan 2.5 supports dubbing and custom audio.
- [Wan 2.6 I2V](https://docs.modellix.ai/alibaba/wan-2-6-i2v.md): Wan image-to-video model generates videos from prompts and images with cinematic quality. Wan 2.6 adds multi-shot narrative, automatic dubbing, and custom audio.
- [Wan 2.6 I2V Flash](https://docs.modellix.ai/alibaba/wan-2-6-i2v-flash.md): Wan image-to-video model generates videos from prompts and images with cinematic quality. Wan 2.6 adds multi-shot narrative, automatic dubbing, and custom audio.
- [Wan 2.6 Image](https://docs.modellix.ai/alibaba/wan-2-6-image.md): The wan-2.6-image supports image editing and mixed text-image output, meeting diverse generation and integration needs.
- [Wan 2.6 T2I](https://docs.modellix.ai/alibaba/wan-2-6-t2i.md): The wan2.6-t2i supports the newly added synchronization interface, while allowing free selection of dimensions within the constraints of total pixel area and aspect ratio.
- [Wan 2.6 T2V](https://docs.modellix.ai/alibaba/wan-2-6-t2v.md): Wan text-to-video model generates videos from text with rich artistic styles. Wan 2.6 adds multi-shot narrative, automatic dubbing, and custom audio support.
- [Wanx 2.1 I2V Plus](https://docs.modellix.ai/alibaba/wanx-2-1-i2v-plus.md): Wan image-to-video model generates videos from prompts and images with rich artistic styles and cinematic quality. Wanx 2.1 Plus offers refined image quality.
- [Wanx 2.1 I2V Turbo](https://docs.modellix.ai/alibaba/wanx-2-1-i2v-turbo.md): Wan image-to-video model generates videos from prompts and images with rich artistic styles. Wanx 2.1 Turbo offers high cost-effectiveness.
- [Wanx 2.1 KF2V Plus](https://docs.modellix.ai/alibaba/wanx-2-1-kf2v-plus.md): The Wan First-and-Last-Frame Video Generation Model: simply provide the first and last frame images, and it can generate a smooth, fluid dynamic video based on the prompt.
- [Wanx 2.1 T2I Plus](https://docs.modellix.ai/alibaba/wanx-2-1-t2i-plus.md): The Wan text-to-image model generates beautiful images from text. The wanx2.1-t2i-plus supports multiple styles and generates images with rich details.
- [Wanx 2.1 T2I Turbo](https://docs.modellix.ai/alibaba/wanx-2-1-t2i-turbo.md): The Wan text-to-image model generates beautiful images from text. The wanx2.1-t2i-turbo supports multiple styles and generates quickly.
- [Wanx 2.1 T2V Plus](https://docs.modellix.ai/alibaba/wanx-2-1-t2v-plus.md): Wan test-to-video model can generate videos from a single sentence, featuring rich artistic styles and cinematic quality. Wanx 2.1 Plus offers even more refined visuals.
- [Wanx 2.1 T2V Turbo](https://docs.modellix.ai/alibaba/wanx-2-1-t2v-turbo.md): Wan test-to-video model can generate videos with a single sentence, featuring rich artistic styles and cinematic quality. Wanx 2.1 Turbo offers high cost-effectiveness.
- [Wanx 2.5 I2V Preview](https://docs.modellix.ai/alibaba/wanx-2-5-i2v-preview.md): Wan image-to-video model generates videos from prompts and images with cinematic quality. Wan 2.5 supports automatic dubbing and custom audio files.
- [Query Task Result](https://docs.modellix.ai/api-reference/query-task-result.md): Query the status and results of an async task by task_id
- [Seedance 1.0 Pro Fast I2V](https://docs.modellix.ai/bytedance/seedance-1-0-pro-fast-i2v.md): Seedance 1.0 Pro Fast inherits core advantages of the Pro model with 3x faster generation and 72% lower cost, balancing quality, speed, and price.
- [Seedance 1.0 Pro Fast T2V](https://docs.modellix.ai/bytedance/seedance-1-0-pro-fast-t2v.md): Seedance 1.0 Pro Fast inherits core advantages of the Pro model with 3x faster generation and 72% lower cost, balancing quality, speed, and price.
- [Seedance 1.0 Pro I2V](https://docs.modellix.ai/bytedance/seedance-1-0-pro-i2v.md): ByteDance's flagship image-to-video model with multi-shot narrative, superior semantic understanding, and cinematic 1080P output in diverse styles.
- [Seedance 1.0 Pro T2V](https://docs.modellix.ai/bytedance/seedance-1-0-pro-t2v.md): ByteDance's flagship text-to-video model with multi-shot narrative, superior semantic understanding, and cinematic 1080P output in diverse styles.
- [Seedance 1.5 Pro I2V](https://docs.modellix.ai/bytedance/seedance-1-5-pro-i2v.md): Seedance 1.5 Pro supports audio-visual co-generation with multi-shot narrative, start/end frame control, and integrated audio output (voice, music, SFX).
- [Seedance 1.5 Pro T2V](https://docs.modellix.ai/bytedance/seedance-1-5-pro-t2v.md): Seedance 1.5 Pro supports audio-visual co-generation with multi-shot narrative, start/end frame control, and integrated audio output (voice, music, SFX).
- [Seedream 4.0 I2I](https://docs.modellix.ai/bytedance/seedream-4-0-i2i.md): SOTA multimodal image model supporting text, single-image, and multi-image inputs for subject-consistent fusion, image editing, and group generation.
- [Seedream 4.0 T2I](https://docs.modellix.ai/bytedance/seedream-4-0-t2i.md): SOTA multimodal image model supporting text, single-image, and multi-image inputs for subject-consistent fusion, image editing, and group generation.
- [Seedream 4.5 I2I](https://docs.modellix.ai/bytedance/seedream-4-5-i2i.md): ByteDance's latest image model with improved editing consistency, portrait refinement, small-text rendering, and enhanced multi-image composition.
- [Seedream 4.5 T2I](https://docs.modellix.ai/bytedance/seedream-4-5-t2i.md): ByteDance's latest image model with improved editing consistency, portrait refinement, small-text rendering, and enhanced multi-image composition.
- [New Models](https://docs.modellix.ai/changelog/new-models.md): The model integration updates and announcements.
- [Product Updates](https://docs.modellix.ai/changelog/product-updates.md): The product updates and announcements.
- [Overview](https://docs.modellix.ai/get-started/index.md): Welcome to Modellix.
- [Model Providers](https://docs.modellix.ai/get-started/model-providers.md): List all model providers of Modellix.
- [Pricing](https://docs.modellix.ai/get-started/pricing.md): The pricing of each model in Modellix.
- [Imagen 4.0 Fast](https://docs.modellix.ai/google/imagen-4-0-fast-generate-001.md): Google Imagen 4.0 Fast text-to-image model optimized for speed. Supports `prompt`, `sampleCount`, `aspectRatio`, and `personGeneration`.
- [Imagen 4.0](https://docs.modellix.ai/google/imagen-4-0-generate-001.md): Google Imagen 4.0 standard text-to-image model. High-quality photorealistic output. Supports batch generation (up to 4), person control, and up to 2K.
- [Imagen 4.0 Ultra](https://docs.modellix.ai/google/imagen-4-0-ultra-generate-001.md): Google Imagen 4.0 Ultra text-to-image model with the highest quality. Optimized for detail and photorealism. Supports batch generation and up to 2K.
- [Nano Banana](https://docs.modellix.ai/google/nano-banana.md): Nano Banana image generation model. Returns results via async task polling. Supports prompt and optional aspect ratio.
- [Nano Banana 2](https://docs.modellix.ai/google/nano-banana-2.md): Nano Banana 2 multimodal image model. Omit `image` for text-to-image or include it for image-to-image. Supports 14 aspect ratios, 512-4K.
- [Nano Banana 2 Edit](https://docs.modellix.ai/google/nano-banana-2-edit.md): Nano Banana 2 multimodal model in image-to-image mode. Requires a base64 data URI image input. Supports multiple aspect ratios and resolutions.
- [Nano Banana Edit](https://docs.modellix.ai/google/nano-banana-edit.md): Nano Banana image editing model. Transforms images based on prompt instructions. Input image must be a base64 data URI.
- [Nano Banana Pro](https://docs.modellix.ai/google/nano-banana-pro.md): Nano Banana Pro image generation model with higher quality output. Supports aspect ratio and image size (1K/2K/4K resolution).
- [Nano Banana Pro Edit](https://docs.modellix.ai/google/nano-banana-pro-edit.md): Nano Banana Pro image editing model with higher quality. Superior detail preservation and prompt adherence. Supports up to 4K.
- [Veo 2 I2V](https://docs.modellix.ai/google/veo-2-i2v.md): Google Veo 2.0 classic image-to-video model. Supports `prompt`, `image`, `aspectRatio`, `durationSeconds` (5/6/8), and `personGeneration`.
- [Veo 2 T2V](https://docs.modellix.ai/google/veo-2-t2v.md): Google Veo 2.0 classic text-to-video model. Supports `prompt`, `aspectRatio`, `durationSeconds` (5/6/8), and `personGeneration`.
- [Veo 3.1 Fast I2V](https://docs.modellix.ai/google/veo-3-1-fast-i2v.md): Google Veo 3.1 Fast image-to-video model. Same capabilities as Veo 3.1 with faster generation. Supports up to 4K. Duration: 4-8s.
- [Veo 3.1 Fast T2V](https://docs.modellix.ai/google/veo-3-1-fast-t2v.md): Google Veo 3.1 Fast text-to-video model. Same capabilities as Veo 3.1 with faster generation. Supports up to 4K and reference images. Duration: 4-8s.
- [Veo 3.1 I2V](https://docs.modellix.ai/google/veo-3-1-i2v.md): Google Veo 3.1 flagship image-to-video model. Supports `prompt`, `image`, `aspectRatio`, `durationSeconds`, `resolution` (up to 4k), and `personGeneration`.
- [Veo 3.1 T2V](https://docs.modellix.ai/google/veo-3-1-t2v.md): Google Veo 3.1 flagship text-to-video model. Supports up to 4K and optional reference images (up to 3) for style consistency. Duration: 4-8s.
- [Veo 3 Fast I2V](https://docs.modellix.ai/google/veo-3-fast-i2v.md): Google Veo 3.0 Fast image-to-video model. Faster generation with the same parameters as Veo 3, supporting resolutions up to **1080p**. Duration: 4/6/8 seconds.
- [Veo 3 Fast T2V](https://docs.modellix.ai/google/veo-3-fast-t2v.md): Google Veo 3.0 Fast text-to-video model. Same capabilities as Veo 3 with faster generation. Supports up to 1080p. Duration: 4-8s.
- [Veo 3 I2V](https://docs.modellix.ai/google/veo-3-i2v.md): Google Veo 3.0 stable image-to-video model. Supports `prompt`, `image`, `aspectRatio`, `durationSeconds`, `resolution` (up to 1080p), and `personGeneration`.
- [Veo 3 T2V](https://docs.modellix.ai/google/veo-3-t2v.md): Google Veo 3.0 stable text-to-video model. Supports `prompt`, `aspectRatio`, `durationSeconds`, `resolution` (up to 1080p), and `personGeneration`.
- [Kling Avatar](https://docs.modellix.ai/kling/kling-avatar.md): Generates realistic talking-head videos from a reference image and audio input, with precise lip synchronization, expressive gestures, and support for multiple languages.
- [Kling Image Expansion](https://docs.modellix.ai/kling/kling-image-expansion.md): Extends images in any direction (up, down, left, right) with prompt-guided generation, ideal for panorama, background extension, and canvas expansion.
- [Kling Image O1](https://docs.modellix.ai/kling/kling-image-o1.md): Multimodal image model accepting text, up to 10 reference images, and element inputs to produce 1K/2K images with precise style control and feature extraction.
- [Kling Image Recognize](https://docs.modellix.ai/kling/kling-image-recognize.md): Detects and segments image content into 4 categories -- object, head (with hair), face (without hair), and clothing -- returning segmentation masks synchronously.
- [Kling V1.5 I2I](https://docs.modellix.ai/kling/kling-v1-5-i2i.md): An upgraded image-to-image model with improved realism, better prompt interpretation, and subject/face reference modes for precise character control.
- [Kling V1.5 I2V](https://docs.modellix.ai/kling/kling-v1-5-i2v.md): The most feature-complete V1.x image-to-video model, adding simple camera motion control alongside motion brush and cfg_scale for precise video generation.
- [Kling V1.5 T2I](https://docs.modellix.ai/kling/kling-v1-5-t2i.md): An enhanced text-to-image model with improved realism and subject/face reference support for generating consistent character images at 1K resolution.
- [Kling V1.6 I2V](https://docs.modellix.ai/kling/kling-v1-6-i2v.md): An improved image-to-video model with significantly better prompt adherence and visual quality over V1.5, supporting first-and-last frame control for smooth transitions.
- [Kling V1.6 MI2V](https://docs.modellix.ai/kling/kling-v1-6-mi2v.md): Transforms up to 4 reference images into a cohesive video sequence with multi-element fusion, enabling character interaction and complex visual narratives.
- [Kling V1.6 T2V](https://docs.modellix.ai/kling/kling-v1-6-t2v.md): An improved text-to-video model with significantly better prompt adherence and visual quality over V1.5, supporting dual standard/professional generation modes.
- [Kling V1 I2I](https://docs.modellix.ai/kling/kling-v1-i2i.md): Kuaishou's first-generation AI image model using a diffusion transformer architecture, capable of generating 1K-resolution images with strong prompt adherence and realistic detail.
- [Kling V1 I2V](https://docs.modellix.ai/kling/kling-v1-i2v.md): Kuaishou's first-generation image-to-video model that animates static images into 5s or 10s videos with motion brush support and adjustable prompt relevance.
- [Kling V1 T2I](https://docs.modellix.ai/kling/kling-v1-t2i.md): Kuaishou's foundational text-to-image model offering fast, cost-effective 1K image generation with strong prompt adherence and multiple aspect ratios.
- [Kling V1 T2V](https://docs.modellix.ai/kling/kling-v1-t2v.md): Kuaishou's first-generation text-to-video model generating 5s or 10s clips with camera motion presets (pan, tilt, zoom) and adjustable prompt relevance.
- [Kling V2.1 I2I](https://docs.modellix.ai/kling/kling-v2-1-i2i.md): The latest cost-efficient image-to-image model offering studio-grade quality with faster rendering and excellent prompt adherence.
- [Kling V2.1 I2V](https://docs.modellix.ai/kling/kling-v2-1-i2v.md): A cost-efficient image-to-video model with advanced frame control and up to 1080p output, suitable for professional content creation.
- [Kling V2.1 Master I2V](https://docs.modellix.ai/kling/kling-v2-1-master-i2v.md): The recommended high-quality image-to-video model in the V2.1 series, producing studio-grade 1080p videos with precise start and end frame control.
- [Kling V2.1 Master T2V](https://docs.modellix.ai/kling/kling-v2-1-master-t2v.md): The V2.1-generation text-to-video model with enhanced rendering quality, improved frame consistency, and studio-grade 1080p output.
- [Kling V2.1 MI2I](https://docs.modellix.ai/kling/kling-v2-1-mi2i.md): The latest and highest-quality multi-image composition model, delivering superior subject fusion, scene replacement, and style transfer with up to 4 subject images.
- [Kling V2.1 T2I](https://docs.modellix.ai/kling/kling-v2-1-t2i.md): The latest and highest-quality text-to-image model in the Kling family, delivering state-of-the-art results at up to 2K resolution.
- [Kling V2.5 Turbo I2V](https://docs.modellix.ai/kling/kling-v2-5-turbo-i2v.md): A speed-optimized image-to-video model delivering cinematic 1080p videos with physics-accurate motion at ~30% lower cost than previous versions.
- [Kling V2.5 Turbo T2V](https://docs.modellix.ai/kling/kling-v2-5-turbo-t2v.md): A speed-optimized text-to-video model delivering cinematic 1080p videos with physics-accurate motion at ~30% lower cost than previous versions.
- [Kling V2.6 I2V](https://docs.modellix.ai/kling/kling-v2-6-i2v.md): First Kling I2V model to natively generate synchronized audio and video in one pass, supporting dialogue, sound effects, lip-sync, and motion brush.
- [Kling V2.6 T2V](https://docs.modellix.ai/kling/kling-v2-6-t2v.md): The first Kling text-to-video model to natively generate synchronized audio and video in one pass, including dialogue, ambient sounds, and lip-synced speech.
- [Kling V2 I2I](https://docs.modellix.ai/kling/kling-v2-i2i.md): A major generational leap in image quality and creativity, featuring enhanced style diversity and significantly improved visual fidelity over V1.5.
- [Kling V2 Master I2V](https://docs.modellix.ai/kling/kling-v2-master-i2v.md): The V2-generation base image-to-video model delivering cinematic-quality animations with superior temporal coherence and smoother motion transitions.
- [Kling V2 Master T2V](https://docs.modellix.ai/kling/kling-v2-master-t2v.md): The V2-generation base text-to-video model producing cinematic-quality clips with superior motion realism and temporal coherence.
- [Kling V2 MI2I](https://docs.modellix.ai/kling/kling-v2-mi2i.md): Combines up to 4 subject images with optional scene and style references into a single cohesive output, supporting subject fusion, scene replacement, and style transfer.
- [Kling V2 New I2I](https://docs.modellix.ai/kling/kling-v2-new-i2i.md): A refined variant of Kling V2 with updated model weights for improved consistency, sharper details, and better prompt-to-image alignment.
- [Kling V2 T2I](https://docs.modellix.ai/kling/kling-v2-t2i.md): A next-generation text-to-image model with significantly improved detail and visual fidelity, supporting both 1K and 2K resolutions for professional output.
- [Kling Video Effects](https://docs.modellix.ai/kling/kling-video-effects.md): Applies 212 preset creative video effects -- including dance, transformation, interaction, and animation styles -- to one or two person images for instant viral content.
- [Kolors Virtual Try-On V1](https://docs.modellix.ai/kling/kolors-virtual-try-on-v1.md): AI-powered virtual try-on built on Kolors diffusion model, generating realistic fitting from a person photo and a garment image (tops, bottoms, or dresses).
- [Kolors Virtual Try-On V1-5](https://docs.modellix.ai/kling/kolors-virtual-try-on-v1-5.md): Enhanced virtual try-on model that supports both single garments and top+bottom outfit combinations, delivering higher-quality results with automatic clothing type detection.
- [Hailuo 02 FL2V](https://docs.modellix.ai/minimax/hailuo-02-fl2v.md): Hailuo 02 FL2V generates dynamic videos between user-defined start and end frames, mastering extreme physics, transitions, and reverse story generation.
- [Hailuo 02 I2V](https://docs.modellix.ai/minimax/hailuo-02-i2v.md): Hailuo 02 masters image-to-video generation with exceptional instruction following and sets a new standard in visual realism via extreme physics.
- [Hailuo 02 T2V](https://docs.modellix.ai/minimax/hailuo-02-t2v.md): Hailuo 02 masters text-to-video generation with exceptional instruction following and sets a new standard in visual realism via extreme physics.
- [Hailuo 2.3 Fast I2V](https://docs.modellix.ai/minimax/hailuo-2-3-fast-i2v.md): Hailuo 2.3 Fast transforms images into dynamic videos with extreme physics mastery, delivering high-quality realistic motion at reduced cost.
- [Hailuo 2.3 I2V](https://docs.modellix.ai/minimax/hailuo-2-3-i2v.md): Hailuo 2.3 generates high-quality videos from images with exceptional instruction following and state-of-the-art extreme physics simulation.
- [Hailuo 2.3 T2V](https://docs.modellix.ai/minimax/hailuo-2-3-t2v.md): Hailuo 2.3 generates high-quality videos from text with exceptional instruction following and state-of-the-art extreme physics simulation.
- [MiniMax I2V-01](https://docs.modellix.ai/minimax/minimax-i2v-01.md): MiniMax I2V-01 converts static images into high-quality video sequences with smooth animation, especially optimized for illustrations and anime.
- [MiniMax I2V-01-Director](https://docs.modellix.ai/minimax/minimax-i2v-01-director.md): I2V-01-Director offers precise camera control for creating professional video clips with cinematic movements through a variety of lens instructions.
- [MiniMax I2V-01-Live](https://docs.modellix.ai/minimax/minimax-i2v-01-live.md): I2V-01-Live is optimized for animating 2D illustrations and cartoons, enhancing smoothness and vivid motion to bring static art to life.
- [MiniMax Image-01 I2I](https://docs.modellix.ai/minimax/minimax-image-01-i2i.md): MiniMax’s multimodal vision model that blends text-to-image generation with visual reasoning for seamless cross-modal tasks.
- [MiniMax Image-01-Live I2I](https://docs.modellix.ai/minimax/minimax-image-01-live-i2i.md): MiniMax’s multimodal vision model that blends text-to-image generation with visual reasoning for seamless cross-modal tasks.
- [MiniMax Image-01 T2I](https://docs.modellix.ai/minimax/minimax-image-01-t2i.md): MiniMax’s multimodal vision model that blends text-to-image generation with visual reasoning for seamless cross-modal tasks.
- [MiniMax S2V-01](https://docs.modellix.ai/minimax/minimax-s2v-01.md): S2V-01 generates videos with highly consistent character identity across frames using a single reference photo, at significantly lower computational cost.
- [MiniMax T2V-01](https://docs.modellix.ai/minimax/minimax-t2v-01.md): MiniMax T2V-01 delivers professional camera movement control, transforming text prompts into cinematic video clips with dynamic shots.
- [MiniMax T2V-01-Director](https://docs.modellix.ai/minimax/minimax-t2v-01-director.md): T2V-01-Director offers precise camera control for creating professional video clips with cinematic movements through a variety of lens instructions.
- [REST API](https://docs.modellix.ai/ways-to-use/api.md): The steps to use the Modellix models API, including how to get an API key, how to use the API, and how to get the result.
- [CLI](https://docs.modellix.ai/ways-to-use/cli.md): Use Modellix from terminal to create model tasks and fetch results.
- [MCP](https://docs.modellix.ai/ways-to-use/mcp.md): Modellix Docs MCP Server allows you to search the Modellix documentation in your MCP clients.
- [Agent Skill](https://docs.modellix.ai/ways-to-use/skill.md)

## OpenAPI Specs

- [google-t2v](https://docs.modellix.ai/model-api/google/google-t2v.json)
- [google-i2v](https://docs.modellix.ai/model-api/google/google-i2v.json)
- [google-t2i](https://docs.modellix.ai/model-api/google/google-t2i.json)
- [google-i2i](https://docs.modellix.ai/model-api/google/google-i2i.json)
- [kling-i2i](https://docs.modellix.ai/model-api/kling/kling-i2i.json)
- [bytedance-t2v](https://docs.modellix.ai/model-api/bytedance/bytedance-t2v.json)
- [alibaba-t2v](https://docs.modellix.ai/model-api/alibaba/alibaba-t2v.json)
- [alibaba-t2i](https://docs.modellix.ai/model-api/alibaba/alibaba-t2i.json)
- [minimax-t2v](https://docs.modellix.ai/model-api/minimax/minimax-t2v.json)
- [minimax-t2i](https://docs.modellix.ai/model-api/minimax/minimax-t2i.json)
- [minimax-i2v](https://docs.modellix.ai/model-api/minimax/minimax-i2v.json)
- [minimax-i2i](https://docs.modellix.ai/model-api/minimax/minimax-i2i.json)
- [kling-t2v](https://docs.modellix.ai/model-api/kling/kling-t2v.json)
- [kling-t2i](https://docs.modellix.ai/model-api/kling/kling-t2i.json)
- [kling-i2v](https://docs.modellix.ai/model-api/kling/kling-i2v.json)
- [bytedance-t2i](https://docs.modellix.ai/model-api/bytedance/bytedance-t2i.json)
- [bytedance-i2v](https://docs.modellix.ai/model-api/bytedance/bytedance-i2v.json)
- [bytedance-i2i](https://docs.modellix.ai/model-api/bytedance/bytedance-i2i.json)
- [alibaba-i2v](https://docs.modellix.ai/model-api/alibaba/alibaba-i2v.json)
- [alibaba-i2i](https://docs.modellix.ai/model-api/alibaba/alibaba-i2i.json)
- [query-task-result](https://docs.modellix.ai/common-api/query-task-result.json)
- [openapi](https://docs.modellix.ai/api-reference/openapi.json)

## Optional

- [Support](mailto:[email protected])
- [Community](https://discord.gg/N2FbcB2cZT)


Built with [Mintlify](https://mintlify.com).
FILE:references/capability-matrix.md
# Capability Matrix

Use this matrix to switch between CLI and REST without changing task semantics.

| Capability | CLI | REST | Notes |
| --- | --- | --- | --- |
| Submit async task | `modellix-cli model invoke --model-slug <provider/model> --body/--body-file ...` | `POST /api/v1/{provider}/{model_id}/async` | Both return `get_result` with polling URL |
| Poll task status/result | `modellix-cli task get <task_id>` | `GET /api/v1/tasks/{task_id}` | Same status lifecycle: `pending` / `processing` / `success` / `failed` |
| API key auth | `MODELLIX_API_KEY` or `--api-key` | `Authorization: Bearer <key>` | Prefer env var for both |

## Slug Mapping

- `model-slug` uses `provider/model` format for both CLI and REST.
- REST path transformation:
  - Input: `bytedance/seedream-4.5-t2i`
  - Derived path parts: `provider=bytedance`, `model_id=seedream-4.5-t2i`

## Fallback Rules

Use REST when any condition is true:
- `modellix-cli` not installed
- CLI auth unavailable
- CLI command surface does not expose required behavior

Otherwise use CLI-first.

FILE:references/cli-playbook.md
# CLI Playbook

Use this reference when `modellix-cli` is available and authenticated.

## Install

```bash
npm install -g modellix-cli
modellix-cli --version
```

## Authentication

Preferred:

```bash
export MODELLIX_API_KEY="your_api_key"
```

PowerShell:

```powershell
$env:MODELLIX_API_KEY="your_api_key"
```

Alternative per-command:

```bash
modellix-cli ... --api-key <your_api_key>
```

## Core Command Flow

1) Invoke async task:

```bash
modellix-cli model invoke \
  --model-slug bytedance/seedream-4.5-t2i \
  --body '{"prompt":"A cinematic portrait of a fox in a misty forest at sunrise"}'
```

`--model-slug` is required and must use `provider/model` format, for example:
- `bytedance/seedream-4.5-t2i`
- `alibaba/qwen-image-edit`

The response includes a `get_result` section with the polling endpoint:

```json
{
  "code": 0,
  "message": "success",
  "data": {
    "status": "pending",
    "task_id": "task-abc123",
    "model_id": "model-123",
    "get_result": {
      "method": "GET",
      "url": "https://api.modellix.ai/api/v1/tasks/task-abc123"
    }
  }
}
```

2) Poll task result:

```bash
modellix-cli task get <task_id>
```

## Polling Guidance

- Start with 1-2s delay
- Use exponential backoff (`1s -> 2s -> 4s`, cap near 10s)
- Stop on `success` or `failed`

## Error Handling

The CLI surfaces API errors directly:
- `400`: invalid request body or parameters
- `401`: invalid/missing API key
- `402`: balance/billing issue
- `404`: invalid task or model slug
- `429`: retry with backoff
- `500`/`503`: retry up to 3 times with backoff

## Platform Notes

- Prefer `--json` output for machine-readable parsing.
- On Windows PowerShell, set env vars with `$env:VAR_NAME="value"`.