Open source AI video generation platform

Video generation without the paywall or the guesswork.

AI video today is either hidden behind a paywall that gets more expensive the more you use it, or "free" in name only — the open models exist, but running one yourself means figuring out which model fits your hardware and wiring up the whole pipeline by hand. Fraime detects your hardware and picks the best open model it can actually run.

pip install fraime-sdk · MIT licensed · self-hosted, no token metering
SCROLL
The problem

The gap isn't a lack of capable open models.

It's the friction and hardware guesswork standing between you and using them. Video creation without AI is still a slow, manual process — and "free" open source models still take a systems engineer to actually run.

Closed platforms
The bill keeps climbing with every clip you render.
  • Token-metered pricing that gets more expensive the more you actually use it.
  • No visibility into which model ran, or why.
  • You're locked into whatever the vendor decides to expose.
Fraime
Your own hardware, matched to a model it can actually run.
  • Detects accelerator, VRAM, RAM, and disk — then picks a model, no guessing.
  • Only unconditionally free-licensed models (Apache-2.0/MIT) in the catalog.
  • Self-hosted: your hardware, your data, no per-token bill.
8
curated open video models — Apache-2.0/MIT only, no MAU caps, no revenue thresholds, no academic-only licenses.
api/instructions/models.json
13
video types out of the box, each with its own prompt fields and evaluation criteria — from pixar to UGC product reviews.
api/instructions/rules.json
8–80GB
VRAM matched exactly against each model's real figures — not coarse hardware "tiers."
api/detector/matcher.py
The vision

Nobody should need to be a systems engineer to use an open model.

And nobody should have to pay a token-metered paywall for something their own hardware can already do. Fraime's bet is that automatically matching hardware to the right model — instead of making a human do that matching by hand — is what actually makes self-hosted AI media generation practical, not just theoretically free. Video is the first medium supported, with more planned.

How it works

Detect. Match. Generate.

Three steps, none of them manual.

1

Detect your hardware

Accelerator (CUDA/MPS/CPU), VRAM, system RAM, and disk space — read straight off the machine it's running on.

2

Match the best open model

Exact capabilities and VRAM figures compared against exact hardware numbers — not coarse tiers. No model fits? It tells you why instead of guessing.

3

Structure, generate, deliver

Prompt fields and evaluation rules per video type shape the request; the video comes back as a local file or a presigned S3 URL.

Your request
SDK, MCP tool call, or a plain curl to /generate.
Fraime API
Matches hardware to a model, structures the prompt, runs the pipeline.
Generated video
A local .mp4, or a presigned S3 URL if cloud output is configured.
Why it matters

The catalog only holds models that are unconditionally free to run — Apache-2.0/MIT, no MAU caps, no revenue thresholds. Matching happens on exact VRAM figures, with an optional safety margin reserved for real-world spikes like VAE decode.

What you get back

The response reports which model actually ran — auto-selection doesn't have to mean a mystery box. GET /config/models and GET /config/rules let you inspect the exact catalog and prompt rules the running instance is using, any time.

# POST /generate
curl -X POST http://127.0.0.1:8000/generate \
  -H "Content-Type: application/json" \
  -d '{
    "video_type": "commercial_product_ad",
    "fields": {
      "subject": "a matte black ceramic mug",
      "action": "slowly rotates as steam rises",
      "scene": "a marble kitchen counter",
      "camera": "smooth slow orbit",
      "lighting": "controlled studio softbox",
      "style": "polished commercial product photography"
    },
    "params": {"duration_s": 5, "fps": 16, "resolution": "768x512"}
  }'

# the model that actually ran
{"model": "Wan-AI/Wan2.2-TI2V-5B-Diffusers", ...}

Its own model catalog, with a customization tool

Models ship in instructions/models.json — capabilities, VRAM requirements, license, style strengths. Extend it with the interactive define tool instead of hand-editing JSON.

Prompt structure per video type

instructions/rules.json defines the fields, style guidance, and evaluation criteria for each of the 13 video types — also editable through define.

Introspection endpoints

GET /config/models and GET /config/rules return exactly what the running instance is configured with — no guessing or hardcoding it client-side.

Optional S3 output

Set CLOUD_S3_OUTPUT_BUCKET and generated videos upload straight to S3, with a presigned URL good for an hour, instead of piling up on local disk.

What's in the box

Three components, each self-contained.

Its own setup, its own docs, its own version — pick what you need.

api/

The generation engine — run it yourself

Hardware detection, model catalog, prompt-structure rules, and the /generate endpoint. Start here.

  • Works with any diffusers-compatible Hugging Face model
  • Own model catalog + prompt rules, customizable via a CLI editor
  • Optional S3 output with presigned URLs
  • API-key auth, off by default
settable by Docker — one image, GPU passthrough
docker pull santsq18/framie-api:latest docker run --gpus all -p 8000:8000 --env-file .env santsq18/framie-api:latest CUDA-enabled base image — a Linux host with an NVIDIA GPU
Read the API docs
sdk/

pip install fraime-sdk

A typed Python client — build a request with typed models/enums instead of hand-writing JSON.

  • One FraimeClient, typed fields/enums per video type
  • Typed access to the model catalog and prompt rules
  • FraimeAuthError / FraimeAPIError / FraimeConnectionError instead of raw HTTP errors
quick start
pip install fraime-sdk from fraime import FraimeClient, VideoType client = FraimeClient(base_url="http://127.0.0.1:8000")
Read the SDK docs
mcp/

Agentic access, over MCP

An MCP server exposing the API to agentic workflows, built directly on the SDK.

  • generate_video — every API param, with rich field descriptions
  • list_video_types, get_models_config, get_rules_config — introspect before generating
  • Works with Claude Code, Claude Desktop, or anything that speaks MCP over stdio
quick start
pip install fraime-mcp or uvx fraime-mcp
Read the MCP docs
See it in action

One request, one generated clip.

Auto-selected model, structured prompt, generated end-to-end — no manual pipeline wrangling.

The model picked depends on your own hardware, so results won't be byte-identical to this one. Watch the full demo →

Your hardware can already do this.

Self-hosted, MIT licensed, no per-token bill — pick a component and start.