---
title: "Ralphy vs Higgsfield Supercomputer — open-source, no vendor lock, reels at model cost"
description: "An MIT-licensed CLI that calls OpenRouter and ElevenLabs at list price vs Higgsfield's hosted Supercomputer with expiring credits, harvested prompts, and a vendor-locked model menu. Real OpenRouter pricing pulled 2026-05-26."
date: "2026-05-21"
authors: ["alecs5am"]
category: "Comparisons"
visibility: "public"
tags: ["comparison", "open-source", "cli"]
---

<Lede>
Higgsfield's <Tag>Supercomputer</Tag> is hosted and closed-source. It
plans the brief, picks the model from a menu they curate, runs the
render on their servers, and bills you in credits that expire on a
timer. <Tag kind="accent">Ralphy</Tag> is the inverse: an
<b>MIT-licensed CLI</b> that uses your own OpenRouter and ElevenLabs
keys, runs on your machine, and writes every generation to your disk.
You pay the model vendor directly, at list price. There's no markup
and no platform fee. Want to swap Kling for Seedance or Veo? Edit one
line in <Tag>MODELS.md</Tag>.
</Lede>

<StatRow>
  <Stat value="MIT" label="License" />
  <Stat value="$0" label="Platform fee" />
  <Stat value="0d" label="Credit expiry, ever" />
</StatRow>

If you ship one reel a quarter and don't write code, a Higgsfield
subscription is faster to set up and you'll feel the difference on day
one. Add a coding agent or a campaign that runs all year and the
constraints flip. Credits forfeit. Prompts get harvested. The model
menu is whatever Higgsfield negotiated this quarter. You usually
notice around month six.

## What Higgsfield Supercomputer is, accurately

Supercomputer launched on May 14, 2026. It's Higgsfield's umbrella
product, an agentic stack that wraps their existing studios into one
"describe it and ship" loop. The headline pieces:

- **Cinema Studio 3.5** — 3 camera bodies, 5 lens types, 5 focal lengths
  (including the new 75mm), 3 apertures, plus 70+ motion presets
  (dolly, crane, FPV, crash zoom, bullet-time).
- **Marketing Studio** — 25+ hook variations, the Virality Predictor
  (Hook Score, Hold Rate, brain-heatmap), and a Hermes-driven campaign
  builder.
- **Soul ID** — train a digital double from your photos so the face
  holds across angles, lighting, and styles.
- **40+ built-in tools** orchestrated by the agent — scriptwriting,
  upscaling, audio mixing.
- **Multi-model out of the box** — Seedance 2.0, Kling 3.0, Veo 3,
  Sora 2, Wan 2.6, MiniMax Hailuo 02 on the video side; Nano Banana Pro,
  Seedream 5.0 Lite, Flux.2 Pro, GPT Image on the still side.
- **Swappable LLM driver** — the agent runs on GPT 5.5 Pro, Claude
  Sonnet, Claude Opus 4.6, or Gemini 3.1 Pro.

Soul ID is ahead of any open-source pipeline for identity-locked faces
right now. Cinema Studio's camera vocabulary is more granular than a
prompt template you'd write by hand. The rest of this article doesn't
argue with that.

What it does argue with is what the pitch leaves out: what the credits,
the data posture, and the closed pipeline cost you after the first reel
ships.

## The five things you actually own when you self-host

Hosted studios optimize for "type a brief, get a video." Ralphy is for
the boring part that comes after. Shipping reels every week. Pulling
up last quarter's scene-04 prompt because the rewrite needs to match
it. Telling the CMO what you spent on regens in Q1 without having to
email someone's support inbox.

- **Your keys, your rates.** Every model call goes direct to <Tag>OpenRouter</Tag>
  and <Tag>ElevenLabs</Tag> at list price. No platform markup, no
  credit-to-model lookup table to re-derive every time a vendor moves.
- **A grep-able generation log.** Each project writes
  <Tag kind="neutral">generations.jsonl</Tag>: prompt, output URI,
  latency, cost, model id, append-only. Not a "history" tab in someone
  else's dashboard.
- **No expiring credits.** No Ralphy account, so no balance that resets
  monthly and no 90-day timer ticking on top-ups you bought last quarter.
- **Reference fidelity in your repo.** <Tag kind="accent">ralphy ref</Tag>
  writes structured JSON for master shots, persona descriptors, and
  camera grammar. All committed. Re-runnable next year, after the vendor
  has changed three model versions.
- **A deterministic render pass that's just code.** The composition is
  HyperFrames (HTML + GSAP) or Remotion (React + headless Chromium) —
  caption timing, transition curves, music ducking are all TypeScript
  you can diff. Want to overlay your own A/B-test telemetry on the
  render? It's a `<div>`.

<Callout kind="good" title="Pass-through, not free">
Ralphy itself has no platform fee — OpenRouter charges you for the
model, ElevenLabs for the voice, and Ralphy is the binary that wires
them up. That's "no markup", not "no cost". Real numbers a few
sections down.
</Callout>

<Cta
  title="Ship reels on a cadence."
  caption="Two API keys, zero account. ralphy doctor verifies the install in five seconds."
  href="https://github.com/alecs5am/ralphy"
  cta="Get Ralphy"
/>

## The straight comparison

Same job (vertical reel that doesn't look like AI vomit), two operating
models.

### Platform & control

<ComparisonTable
  brands={[
    { name: "Ralphy", accent: true },
    { name: "Higgsfield Supercomputer" }
  ]}
  rows={[
    { feature: "Open source",         values: [true, false] },
    { feature: "Self-hosted",         values: [true, false] },
    { feature: "BYO provider keys",   values: [true, false] },
    { feature: "Pay providers at list", values: [true, false] },
    { feature: "Agent-native CLI",    values: [true, "partial"] },
    { feature: "Web UI",              values: [false, true] },
    { feature: "MCP integration",     values: [true, true] },
    { feature: "One-click setup",     values: [false, true] }
  ]}
/>

### Reproducibility and audit

<ComparisonTable
  layout="rows"
  brands={[
    { name: "Ralphy", accent: true },
    { name: "Higgsfield Supercomputer" }
  ]}
  rows={[
    { feature: "Per-project JSONL log", sub: "Every prompt + output + cost, append-only, on your disk", values: [true, false] },
    { feature: "Versioned prompts",     sub: "prompts.json checked into git",                            values: [true, false] },
    { feature: "Re-runnable storyboard", sub: "STORYBOARD.md as source of truth",                        values: [true, false] },
    { feature: "Reference blueprints",  sub: "Persona, brand, camera in JSON",                           values: [true, "partial"] },
    { feature: "Branchable history",    sub: "git diff your prompt revisions",                           values: [true, false] },
    { feature: "Export full history",   sub: "Cost rollup, model breakdown, raw outputs",                values: [true, "partial"] }
  ]}
  caption="Reproducibility matrix · 2026-05"
/>

### Model coverage

Both stacks ship the same frontier model menu. The difference is the
billing path that wraps it.

<ComparisonTable
  layout="rows"
  brands={[
    { name: "Ralphy", accent: true },
    { name: "Higgsfield Supercomputer" }
  ]}
  rows={[
    { feature: "Video: Kling 3.0 / 3.0-pro",      sub: "Lipsync VO via --audio in EN, no post-mix",  values: [true, true] },
    { feature: "Video: Seedance 2.0",             sub: "POV / horror / non-default physics",        values: [true, true] },
    { feature: "Video: Veo 3, Sora 2",            sub: "Cinematic high-end",                        values: [true, true] },
    { feature: "Image: gpt-image-2, nano-banana", sub: "Best-in-class for refs + scenes",           values: [true, true] },
    { feature: "Voice: ElevenLabs v3 + multilingual v2", sub: "EN premium + clean RU/UA/ES",         values: [true, "partial"] },
    { feature: "Music: ElevenLabs Music",         sub: "Genre + tempo prompt, no licensing chase",  values: [true, false] },
    { feature: "Soul ID character consistency",   sub: "Higgsfield-only; ahead of OSS today",       values: ["partial", true] },
    { feature: "Cinema Studio camera presets",    sub: "70+ motion presets, focal-length controls", values: [false, true] },
    { feature: "Swap models without a release",   sub: "Edit MODELS.md, restart",                   values: [true, false] }
  ]}
/>

### Pricing model

<ComparisonTable
  brands={[
    { name: "Ralphy", accent: true },
    { name: "Higgsfield Supercomputer" }
  ]}
  rows={[
    { feature: "Platform fee",                values: ["$0", "$15-99/mo, billed annually"] },
    { feature: "Token markup",                values: [false, true] },
    { feature: "Monthly credits roll over",   values: ["n/a (no credits)", false] },
    { feature: "Top-up expiry",               values: ["n/a", "90 days"] },
    { feature: "Refund window",               values: ["n/a", "7 days, zero credits used, 6% fee"] },
    { feature: "Prompts used as training data", values: [false, true] },
    { feature: "Team / seat fees",            values: [false, true] }
  ]}
/>

<Callout kind="warn" title="What the Higgsfield terms actually say">
Two clauses worth pulling out of the small print, because they don't
make it onto the pricing page:

- **Credits forfeit on cancellation.** Refunds only land within 7 days
  AND only if you've used zero credits, minus a 6% service fee.
  Top-up packs expire after 90 days. Monthly credits don't roll over.
- **Your prompts are training data.** User prompts are collected for
  model improvement, and Soul ID face uploads are marked "usable for
  service improvement" in the Privacy Policy.

These are documented, not invented. They're also exactly the constraints
Ralphy doesn't have — because there's no account, no central storage,
and your prompts.json sits in your git repo.
</Callout>

## What a reel actually costs (real OpenRouter prices, pulled 2026-05-26)

An earlier draft of this page claimed Ralphy was cheaper than
Higgsfield by an order of magnitude. That was wrong, and the table
below is the corrected math.

The real story is dull. Ralphy charges you what OpenRouter charges
OpenRouter's direct API users — the same number, no platform fee, no
credit conversion, no expiry timer. The binary just wires the
providers together.

Numbers pulled live from the OpenRouter model pages:

<PricingTable
  cols={["Model", "OpenRouter rate", "5-second clip"]}
  rows={[
    { label: "kwaivgi/kling-v3.0-pro",   values: ["$0.168 / sec",              "$0.84"] },
    { label: "google/veo-3.1",           values: ["$0.40 / sec",               "$2.00"] },
    { label: "google/veo-3.1-fast (4K)", values: ["$0.10 / sec",               "$0.50"] },
    { label: "bytedance/seedance-2.0",   values: ["$7 / M tokens (W·H·d·24/1024)", "~$0.76 (720p) / ~$1.70 (1080p)"] },
    { label: "openai/gpt-5.4-image-2",   values: ["$8 in + $15 out / M tokens", "~$0.05 / image (1024²)"] },
    { label: "google/nano-banana-pro",   values: ["$2 in + $12 out / M tokens", "~$0.04 / image"] }
  ]}
  caption="Live OpenRouter pricing · pulled 2026-05-26 · pass-through to Ralphy"
/>

A canonical 30-second vertical reel on Ralphy — six 5-second scenes,
six ref frames, one VO, one music bed — costs roughly:

<PricingTable
  cols={["Line item", "Cheap mix (veo-fast)", "Default mix (kling-pro)", "Premium mix (veo-3.1)"]}
  rows={[
    { label: "6 × video clips (5s each)",   values: ["~$3.00",   "~$5.04",   "~$12.00"] },
    { label: "6 × reference images",        values: ["~$0.24",   "~$0.30",   "~$0.30"] },
    { label: "Scenario / scoring LLM",      values: ["~$0.10",   "~$0.20",   "~$0.30"] },
    { label: "ElevenLabs VO + Music",       values: ["subscription", "subscription", "subscription"] },
    { label: "Render compute",              values: ["$0",       "$0",       "$0"] },
    { label: "Total OpenRouter pass-through", values: ["~$3.34", "~$5.54",   "~$12.60"] }
  ]}
  caption="Per-reel cost at model cost price · 30s reel, 9:16 · ElevenLabs sub (~$22/mo) amortized separately"
/>

Default mix lands at **$5-6 per reel**. The veo-3.1-fast cheap mix
(the only 4K model in the catalog) drops to **~$3.30**. Heavy regens,
premium models, or 60-second reels push it up. The cost isn't
estimated; `ralphy render` writes each call's actual price into
<Tag>generations.jsonl</Tag> as the render happens. You can `cat` it.

The same Kling reel on Higgsfield runs about 7 credits on Plus. With
1,000 credits a month, that's room for ~142 Kling reels. Face-value
math is $0.27 per reel, if you burn every credit. At 10 reels a month
you use 70 of them and the other 930 evaporate at month-end. Effective
cost is $3.90 per reel shipped, and you can't change which video model
that buys you without changing your subscription tier.

<PricingTable
  cols={["Volume", "Ralphy (default mix)", "Ralphy (cheap mix)", "Higgsfield Plus", "Higgsfield Ultra"]}
  rows={[
    { label: "10 reels/mo",   values: ["~$55",  "~$33",  "$39 (930 credits forfeit)",  "$99 (overkill)"] },
    { label: "25 reels/mo",   values: ["~$138", "~$83",  "$39 (825 credits forfeit)",  "$99 (2,825 forfeit)"] },
    { label: "60 reels/mo",   values: ["~$330", "~$200", "$39 + ~$25 top-up",           "$99 (2,580 forfeit)"] },
    { label: "100 reels/mo",  values: ["~$550", "~$330", "needs Ultra",                 "$99 + ~$110 top-up"] },
    { label: "Seats included", values: ["unlimited", "unlimited", "3",                  "5"] }
  ]}
  caption="Default mix = kling-v3.0-pro. Cheap mix = veo-3.1-fast. ElevenLabs sub additive."
/>

At low-to-mid volume the Higgsfield headline number is cheaper. That's
true. It only stays true if you burn every credit before it expires,
which most teams don't. The face-value arithmetic ignores the forfeit,
the markup, and the fact that you can't change models without changing
tiers.

Where Ralphy actually wins is around the invoice, not on it:

- **Vendor list price, no markup.** Whatever OpenRouter charges is the
  line item. We keep zero.
- **Nothing forfeits.** Render nothing this month and the bill is
  zero. The ~$36 of unused Plus credits that vanish at month-end on
  Higgsfield don't exist here.
- **No vendor lock.** Edit one entry in `MODELS.md`, restart. The
  pipeline doesn't care which vendor's weights run the clip. On
  Higgsfield the menu changes when Higgsfield re-negotiates it.
- **A budget your agent enforces.** Set a per-reel ceiling in
  `MODELS.md`; the agent refuses to regen past it. The hosted
  equivalent is the credit bar going red.

## Ralphy is open-source and pluggable. Higgsfield is a closed studio.

Higgsfield is a closed studio. Forty-plus tools, one fixed agent, one
fixed render path, a model menu they curate. You take what the product
team picked. Ralphy is a harness. MIT-licensed code, every provider
call funneled through two small files
(<Tag>cli/lib/providers/media.ts</Tag> and
<Tag>cli/lib/providers/llm.ts</Tag>), and a rendering layer that's
just HTML or React. Fork it, vendor it into your repo, or rewrite any
piece you don't like.

That difference compounds in four places hosted studios can't follow
you to:

- **No vendor lock on models.** OpenRouter alone fronts ~200 models
  across OpenAI, Google, Anthropic, Black Forest Labs, Kwaivgi,
  ByteDance, MiniMax, and a dozen smaller labs. Want to swap Kling for
  Seedance for Veo for whatever ships next month? Edit one entry in
  `MODELS.md`, restart. The pipeline doesn't care which vendor's
  weights run the clip. Higgsfield's menu is fixed at their
  negotiation cycle.
- **Pluggable providers.** Want to add an internal eval endpoint, a
  private Stable Diffusion finetune, or a custom captions backend?
  Write a function. The MIT license means you can fork, modify, ship,
  and never owe upstream anything.
- **Custom hooks and your data.** Wire your own brand database, your
  A/B-test retention curves, your previous campaign's hook scores into
  the scenario prompt. Ralphy reads `brand`, `persona`, `ref`
  resources from disk — your files, your schema, your data, never
  shipped off-machine.
- **Postmortem-driven learning.** Every finished project can write a
  `postmortem/` directory with lessons learned, the model swaps that
  worked, the prompts that didn't, and a per-reel cost rollup. The
  agent reads them when it scopes the next brief. The longer you run
  it, the more it knows about *your* register specifically, not the
  median across Higgsfield's customer base.

Hosted platforms can't ship this. The whole pitch for Supercomputer is
"we pick the tools, you don't think about them." A harness makes the
opposite trade. You or your agent make the calls, the tool stays out
of the way, and the choices stack into something portable that's
actually yours.

## What Higgsfield Supercomputer actually does better

Some things they ship today that Ralphy genuinely doesn't match.

A web UI a designer can click in. Ralphy is CLI-first; the assumed
driver is a coding agent. Higgsfield ships a clickable stack that
works without a terminal.

Soul ID character consistency. Training a digital double from a few
reference photos and getting consistent facial geometry across angles
and lighting is real, polished work. Ralphy's reference pipeline uses
checked-in master-shot images and `--ref` on each generate call, which
works but is less plug-and-play.

Cinema Studio's camera language. The combination of camera body, lens,
focal length, aperture, and 70+ named motion presets is more granular
than a prompt template. If your work depends on cinematic camera
grammar and you don't want to write it longhand, Higgsfield gets you
closer faster.

One-pass audio plus video. Higgsfield renders sync'd lipsync, ambient
beds, and music in a single agent call. Ralphy does this through Kling
`--audio` for English VO and an ElevenLabs overlay in the editor pass,
which is more steps.

Zero setup. No `bun`, no env vars, no `ralphy doctor`. If your team
doesn't write code, that gap is the whole conversation.

If those matter more than the audit log, the credit math, and the data
posture, Higgsfield is the right call. This article isn't trying to
talk you out of it.

## What "AI-native" looks like in practice

The teams that get the most out of Ralphy share a few habits. None of
them are Ralphy-specific. They're just how AI-native teams operate in
general.

<Steps>
  <Step n="01" title="Treat prompts like code">
    Prompts live in git. Ralphy drops <Tag>prompts.json</Tag> and
    <Tag>STORYBOARD.md</Tag> into every project, both committed. Your
    prompt history sits next to your application code instead of in a
    SaaS dashboard somewhere.
  </Step>
  <Step n="02" title="Let an agent drive the CLI">
    The bundled agent reads `AGENTS.md`, picks the right playbook for
    the brief, runs the matching `ralphy` verbs, reads the postmortems
    from previous projects, and writes the logs. The human reviews the
    diff and the mp4. Same loop as any pull request.
  </Step>
  <Step n="03" title="Retrofit, don't replace">
    Ralphy doesn't replace Figma, Notion, or Linear. It slots in
    between the brief and the render. The rest of your stack stays
    where it is, and migration happens one project at a time.
  </Step>
</Steps>

If that's the loop you're already in, or where you're heading by Q4,
you don't need a hosted studio. You need a CLI you can pin to a
specific commit and an agent that knows when to refuse to render.
Being able to grep your own prompt history in Slack is a nice bonus.

## Recommendations by team type

<TeamRecs>
  <TeamRec team="engineering-led product teams" pick="Ralphy">
    Direct provider access, version-controlled prompts, and an
    MIT-licensed binary you can pin to whatever commit you trust. The
    CLI is built to be driven by Claude, Cursor, or Codex, so your
    code-gen agent and your video-gen agent share the same interface.
  </TeamRec>
  <TeamRec team="brand / creative teams without engineering support" pick="Higgsfield">
    Web UI, polished templates, Soul ID for character consistency, no
    terminal anywhere. You give up the audit log, the data posture, and
    the ability to pin a model version, but you get a dashboard a
    designer can use on day one.
  </TeamRec>
  <TeamRec team="ai-native marketing teams shipping ≥10 reels/week" pick="Ralphy">
    At volume the conversation isn't "Plus or Ultra", it's how many
    top-up packs you'll burn through and how many will expire before
    you use them. Pass-through pricing plus a per-reel budget the
    agent enforces skips the entire credit-arithmetic loop.
  </TeamRec>
  <TeamRec team="compliance-sensitive industries (finance, health, gov)" pick="Ralphy">
    Generations stay on your disk. Prompts are not training data.
    Reference imagery, prompts, and rendered outputs never sit in a
    third-party studio's S3 bucket. No central account that can be
    banned, frozen, or have policy changes applied retroactively.
  </TeamRec>
  <TeamRec team="creators who depend on Soul ID consistency" pick="Higgsfield">
    Honest answer: if your work hinges on locking a specific face
    across hundreds of generations, Higgsfield's Soul ID is ahead of
    what an open-source pipeline gets you today. Ralphy's `ref`
    primitives are catching up, but they're not there yet for fashion
    or talent-driven work.
  </TeamRec>
  <TeamRec team="single-operator solopreneurs" pick="Either">
    At &lt;10 reels a month, the credit constraints are mostly
    invisible (you'll use what you bought, or you won't notice the
    forfeit). Pick whichever interface matches your day-to-day. Solo
    on Claude Code? Ralphy. Solo in a browser? Higgsfield.
  </TeamRec>
</TeamRecs>

<LinkList head="Keep reading">
  <LinkListItem
    href="https://github.com/alecs5am/ralphy"
    num="01"
    title="github.com/alecs5am/ralphy"
    meta="repo · MIT"
  />
  <LinkListItem
    href="https://ralphy.mintlify.app"
    num="02"
    title="Ralphy documentation"
    meta="docs"
  />
  <LinkListItem
    href="https://ralphy.mintlify.app/cli"
    num="03"
    title="CLI surface — every verb, every flag"
    meta="reference"
  />
</LinkList>

## Frequently asked questions

<FAQ>
  <FaqItem q="What's the actual difference between Ralphy and Higgsfield Supercomputer?" open>
    Ralphy is an open-source CLI you run locally, calling OpenRouter
    and ElevenLabs with your own keys. Higgsfield Supercomputer is a
    hosted agentic stack that owns the pipeline (studios, models,
    storage, the agent driving it) and bills you in credits. You're
    trading a polished web UI and Soul ID for an audit log, version
    control, pass-through pricing, and a data posture where your
    prompts aren't training material.
  </FaqItem>
  <FaqItem q="Does Ralphy replace Higgsfield?">
    For AI-native teams already running CLI tools and coding agents,
    yes for most workflows. For teams whose creative process depends
    on Soul ID character consistency or the polished Cinema Studio
    camera grammar, no. Both products do real work; the question is
    which constraint set matches your team's habits.
  </FaqItem>
  <FaqItem q="So is Ralphy actually cheaper?">
    You pay the model vendor whatever OpenRouter charges, nothing on
    top. Whether that's cheaper than Higgsfield depends on how many
    credits you'd actually burn. Their headline rate looks cheaper at
    low volume *if you use every credit before it expires*. In
    practice teams forfeit hundreds of credits a month. Ralphy's edge
    is less the unit price and more the structure around it: no
    markup, no expiry, no model lock-in, and a JSONL receipt for every
    call.
  </FaqItem>
  <FaqItem q="What does 'no vendor lock' actually mean?">
    Every model call routes through `cli/lib/providers/media.ts` and
    `cli/lib/providers/llm.ts`. You can change which video model your
    pipeline uses by editing one line in `MODELS.md`. You can add a
    provider Ralphy doesn't ship with by writing a function (it's MIT,
    fork freely). You can run a local model and skip OpenRouter
    entirely. The CLI is a harness; the providers are interchangeable.
    On Higgsfield, the model menu is whatever they negotiated.
  </FaqItem>
  <FaqItem q="How much does Higgsfield Supercomputer actually cost?">
    Three tiers, billed annually: Starter $15/mo with 200 credits,
    Plus $39/mo with 1,000 credits and unlimited access to certain
    image models, Ultra $99/mo with 3,000 credits and one unlimited
    video model of your choice. Top-up packs are roughly $5 per 100
    credits and expire after 90 days. Monthly credits don't roll over.
  </FaqItem>
  <FaqItem q="Why does credit expiry matter?">
    If you're on the Plus tier ($39/mo, 1,000 credits) and a campaign
    slips into the next month, you forfeit whatever's unused. If you
    buy a top-up pack to cover a launch and the launch gets delayed
    past 90 days, that pack is gone. Refunds on annual plans require
    7 days AND zero credits used, minus a 6% service fee. Ralphy
    doesn't have credits, so the question doesn't come up.
  </FaqItem>
  <FaqItem q="What happens to my prompts and reference uploads on Higgsfield?">
    Per their Privacy Policy: user prompts are collected for model
    improvement, and Soul ID face uploads are marked usable for
    "service improvement." If your brand voice, character sheet, or
    competitive positioning lives in those prompts, that data is no
    longer purely yours. On Ralphy, everything is local files. The
    only data leaving your machine is the prompt you send to the
    chosen provider; nothing flows back to a central platform.
  </FaqItem>
  <FaqItem q="Can I use Ralphy and Higgsfield together?">
    Yes. Some teams use Higgsfield's Marketing Studio for
    hook-generation and Soul ID, then render the final cut through
    Ralphy when they need an auditable build. They don't share state
    directly, but reference images and brand kits port over fine.
  </FaqItem>
  <FaqItem q="Does Ralphy have a free tier?">
    Ralphy itself is free and MIT-licensed. The only cost is whatever
    OpenRouter and ElevenLabs charge for tokens — roughly **$5-6 per
    30-second reel** on the default `kwaivgi/kling-v3.0-pro` +
    `openai/gpt-5.4-image-2` stack, or **~$3.30** on the
    `google/veo-3.1-fast` cheap mix (4K). All numbers pulled live from
    OpenRouter on 2026-05-26. There's no platform-side free tier
    because there's no platform.
  </FaqItem>
  <FaqItem q="What models does Ralphy support that Higgsfield doesn't?">
    Both stacks ship the same frontier video models (Kling 3.0,
    Seedance 2.0, Veo 3, Sora 2, Wan 2.6, MiniMax Hailuo 02) and image
    models (gpt-image-2, nano-banana, Flux). The differences are at
    the edges: Ralphy uses ElevenLabs Music for genre-driven beds
    with no licensing chase, and ElevenLabs Multilingual v2 for clean
    Russian / Ukrainian / Spanish voiceover. Higgsfield's audio is
    part of its single-pass video render and is English-strongest.
  </FaqItem>
  <FaqItem q="Can I bring my own brand kit?">
    Yes. Ralphy has first-class `brand`, `persona`, and `ref`
    resources. Drop in your logo SVGs, brand voice notes, and master
    shot images, and every project picks them up automatically. Soul
    ID is the equivalent on Higgsfield's side and is more polished
    today for face-locked work.
  </FaqItem>
  <FaqItem q="Does Ralphy support Russian or non-English voiceover?">
    Yes, through ElevenLabs Multilingual v2. Kling's `--audio` flag is
    canonical for English VO. For non-English we route to ElevenLabs
    and overlay in the editor stage, because Kling's accent slips on
    non-English inputs.
  </FaqItem>
  <FaqItem q="What about account bans and retroactive policy changes?">
    Documented Higgsfield concern: a wave of account closures during
    the 2025 holiday period and reports of previously approved content
    being retroactively blocked after policy revisions, with no refund
    on annual plans. Ralphy doesn't have a central account, so the
    failure mode doesn't apply. Your generations stay on disk; nobody
    can revoke them after the fact.
  </FaqItem>
  <FaqItem q="What ships in the box for templates?">
    43 templates across 5 segment-persona categories: B2B SaaS, DTC
    commerce, creator lifestyle, entertainment / viral, and cinematic
    narrative. 5 are full-stack production templates and 38 are prompt
    cookbooks with hooks, camera vocab, and worked examples.
  </FaqItem>
  <FaqItem q="Can I run Ralphy without an OpenAI account?">
    Yes. Ralphy never calls OpenAI directly. All LLM, image, and video
    routing goes through OpenRouter, which gives you access to OpenAI,
    Anthropic, Google, Black Forest Labs, Kling, Seedance, and others
    through one API key.
  </FaqItem>
  <FaqItem q="How do I migrate from Higgsfield to Ralphy?">
    There's no automated import; Higgsfield's storage is opaque. The
    migration looks like this: download your reference imagery, export
    whatever brand voice notes you wrote into the Marketing Studio,
    and recreate everything as `ralphy brand` / `ralphy ref` resources
    in your repo. After that, every new project runs through Ralphy.
    Most teams keep both going for a sprint and then deprecate the
    hosted account before the annual renewal hits.
  </FaqItem>
  <FaqItem q="What's the catch?">
    You have to install a CLI, manage two API keys, and either drive
    it yourself or wire it to a coding agent. If that's a non-starter,
    the rest of the trade-off doesn't matter. Ralphy is built for
    people who already run terminals.
  </FaqItem>
</FAQ>

<Cta
  title="Try Ralphy in eight minutes."
  caption="brew install alecs5am/tap/ralphy && ralphy new 'vertical reel about <your product>' — cold start to rendered mp4."
  href="https://github.com/alecs5am/ralphy"
  cta="Install"
/>

If you already treat prompts as code and AI agents as coworkers,
Ralphy is the version of this tooling that fits the rest of your
stack. You give it two API keys, it gives you a harness back. Every
model call lands in a grep-able JSONL log. The rendering layer is
code your agent can edit. Each shipped reel writes a postmortem the
next project gets to read.

**Your reels cost what the models cost** — that's the whole pricing
pitch. There's no platform to host. There's no account, so credits
can't sit there expiring on you. Your prompts live in a git repo
where you control them, not in someone else's training set. And the
provider layer is two files, so swapping any model for any other is
an afternoon's work rather than a vendor escalation.
