CreatorOS · Autonomous social-video engine

Give it a niche. Get back a creator.

> RESEARCHING

CreatorOS is the whole engine. It researches your account’s own warmed feed, builds a locked creator identity, renders on-trend 9:16 video across eight formats through 24 generation backends, scores hooks against learned performance, and posts through a real logged-in browser — every paid call on an append-only ledger.

fig. 01 — representative pipeline trace

Research → generate → edit → score → post

Five steps. Zero hands.

One click launches the whole loop. Every step is real code wired into live call sites — not a diagram of intentions.

01

Research

Reads the posting account’s own warmed IG/TikTok feed inside its anti-detect session. No hashtag APIs, no third-hand trend reports.

02

Generate

Frontier models render clips around the account’s locked creator identity — built once at onboarding, recognized in every render after.

03

Edit

A strict multi-cut 9:16 contract: cuts before and after every beat drop, one caption style, music from the account’s own followed artists.

04

Score

Every hook variant is rated against learned performance before anything ships. Below the account’s threshold, hooks re-roll — not you.

05

Post

A real logged-in Chrome session drives the platform UI like a human — typed captions, paced clicks, persisted cookies.

Engagement flows back into the hooks database and the cross-virality recommender. The next render is steered by what actually worked — on your account, not someone else’s.

Fourteen systems · one loop

Everything it does.

Not a roadmap. This is the shipping surface — every row below is real code you can open. Jump to any system.

Eight formats · six engines · one contract

Every format your audience expects — and the list keeps growing.

Content engines, up from three

6

Eight named formats over six real engine types, in five onboarding tiles — plus one admin-gated. Tier List was the latest, added June 2026.

The engines are fixed code; the trends and sounds behind them re-sync every run from the account’s own feed, with a full library review every week (Sundays 10:00 UTC).

Before / Aftertransformation

Curated viral: two library buckets — weak/strong, before/after — paired into a transformation reel.

Podcast Clipsinfluencer

Your AI persona or your real brand talking on camera, lip-synced to a script it wrote for your niche.

Reacting to Thingsinfluencer

Talking-head reaction cut — the creator responds to something the niche is already watching.

Day in a Lifeinfluencer

A ~45-second, three-scene walkthrough: morning ritual, mid-day pain, evening payoff.

Behind the Scenesfaceless b-roll

Faceless b-roll with burned-in text and music — no voice, by design.

B-roll Storytellingfaceless b-roll

Crossfading text slides over muted b-roll, or a hook-card cut — cheap enough to post daily.

Whiteboardresearch b-roll

Topic → researched facts → your own Google Drive footage, assembled with a hook card and CTA — the cheapest format we run.

Tier Listtierlist

The persona ranks 8–12 options S→D on camera; an off-screen narrator names each option, real logos spring into a live tier table.

Personas & personal brands

Two ways to be a creator.

Either way, the identity is locked at onboarding and re-attached to every render — your audience sees the same face every day.

Option A

AI Persona

An invented character locked to a Soul-ID. A Pinterest-grounded anchor photo plus a six-angle reference orbit keep the face consistent across every clip, angle, and format.

  • Synthetic face, locked by a 6-angle Soul-ID orbit
  • Claude-Vision style spec (exact HEX palette)
  • Persona canon steers scripts and tier-list takes
Option B

Personal Brand

Your own face and your own cloned voice. Upload photos once, record a voice sample once — CreatorOS renders the daily talking-head as the real you, and you stop filming.

  • Real face + an upscaled 4K hero from your photos
  • Your voice, cloned once with ElevenLabs
  • You keep final say with the approval gate
The face is built once. Every render after that simply recognizes it.
Video & image providers

Twenty-four backends behind one dropdown.

Two self-registering registries — add a backend and it auto-surfaces in the model picker with no frontend change. fal.ai is the primary gateway.

ProviderModelRoleNote
fal_ai_kling_v3_proKling V3 Pro (fal)video · default~$0.10/s
kling_directKling V3 (official)videoprepaid escape hatch
fal_ai_seedance_2_0Seedance 2.0 (fal)video+ fast / 1.5-pro
fal_ai_veo3_1Veo 3.1 (fal)video+ veo3 / veo3-fast
fal_ai_hailuo_23_proHailuo 2.3 Pro (fal)video+ hailuo / hailuo-pro
fal_ai_gpt_image_2GPT Image 2 (fal)anchor · defaultquality sent explicit
fal_ai_nano_banana_2Nano Banana 2 (fal)pin-edit · real facephoto-accurate edits
FalKlingV3 i2vKling V3 image-to-videotalking-head · defaultlip-sync · needs keys
higgsfield (cli)Seedance / Marketing Studiob-roll · UGC adofficial binary wrapper

18 registered video backends (13 are fal.ai gateway slugs, several billing the same Kling model different ways, one a mock for tests) + 6 anchor-image backends. Opt-in budget-aware routing picks the cheapest backend that clears a quality floor and the remaining spend guard. Per-clip dollar figures are the pricing model’s reservation estimates until real invoices land. Talking-head lip-sync with a cloned voice needs fal or Kling keys set.

18 + 6
video + anchor-image backends registered
/my-models
per-user model switching, live
GPT Image 2
default anchor · Kling V3 default video
auto
opt-in budget-aware provider router
The edit contract

FFmpeg cuts it. Remotion only paints.

Every render, no exceptions

1080×1920

Vertical 9:16 at 30fps, force-cropped with no letterbox — across four Remotion compositions and every FFmpeg assembly.

  • The multi-cut is enforced in Python. Each phase must carry at least two clips — fewer raises an error — so no beat ever lands on a single static shot.

  • Remotion receives pre-baked MP4s. It paints overlays, hook text, flashes and transitions only; the four compositions all render 1080×1920 at CRF 16.

  • One caption style, everywhere. A single Python source of truth burns the TikTok-meme look — heavy white fill, black stroke at 10% of the font — via local rendering; no paid subtitle service on the path.

  • Tier-list face-safe layout. The seated creator fills the frame while the tier table fills the lower band — a coded zone convention (overlays sit below the face), prompted seating, not runtime face detection.

  • Music drop-aligned in post. After the cut, FFmpeg aligns the track to the detected drop, then adds optional grain and shake — raw by default.

Anti-detect posting

The platform sees a human.

API calls on the posting path

0

The write API was retired in 2026. Every upload goes through a real logged-in browser session — the same way you would post it yourself.

  • Real Chrome via Dolphin Anty. Each account owns a persistent anti-detect profile — real Chrome, US residential proxy, logged-in cookies that survive between sessions — driven by Playwright over CDP.

  • Four platform uploaders. Instagram, TikTok, Facebook and YouTube each drive the real web UI; IG and TikTok poll for a genuine post-confirmation. Platform scope is set per account.

  • Human-paced driving. The poster types the caption, waits, scrolls and clicks — no headless shortcuts on the money path, and the “open a new tab first” pattern never kills the session.

  • Mac ↔ server bridge. When Dolphin runs on your Mac and the API on the VPS, a claim-locked publish queue hands each render to local Dolphin and posts the permalink back — no double-posts.

  • Readiness checks & dry-runs. A login-state probe confirms the profile is signed in before posting; TikTok supports a dry-run that stops before the final Post.

Hermes — the agent stack

Eighteen agents keep it running.

A Sonnet orchestrator coordinates the roster; Python only executes what the agents decide. The model split keeps total spend around $2–5 a month.

Intelligence6
  • Research
  • Analytics
  • Competitor
  • Strategy
  • CrossLearning
  • FeedScout
Production5
  • Library
  • VideoProduction
  • Creation
  • Publishing
  • ContentQueue
Operations4
  • Monitor
  • ContentCalendar
  • Diagnostics
  • Assistant
Autonomy3
  • ShadowBan
  • Watchdog
  • CostWatch
The cron schedule (UTC)
JobWhenDrives
library_watchdog06:00LibraryAgent
selector_health06:15selector-drift healthcheck
content_calendar06:30ContentCalendarAgent
morning_routine07:00Orchestrator (fans out)
prepare_next09:00pre-renders tomorrow
monitorevery 30 minMonitorAgent → hooks DB
posting_tickevery minutescheduled upload tick
weekly_reviewSun 10:00analytics + competitor + strategy
billing_reconcile06:00alert-only usage check

Eight cron specs (one is the selector-drift healthcheck, not an agent) plus a reconcile job the API registers at startup — nine in all when autonomy is on. The scheduler is embedded in the API process, no separate worker, and stays off until autonomy is opted in.

18
specialized agents · 19 graph nodes with the orchestrator
$2–5
estimated model spend per month
Sonnet + Haiku
orchestration & creation / everything else
9
cron jobs when autonomy is enabled
Lights-out, on your terms

It runs itself — only after you say so.

Autonomy flags shipped ON

0

Five environment flags are off by default. Out of the box, nothing spends and nothing posts. Flip one switch and it runs itself.

  • Paid autonomy is opt-in. Every paid background job — the per-minute posting tick included — short-circuits until you set the flag, and the scheduler reports itself stopped.

  • The approval gate is the same code path. When an account is review-gated, a render is queued instead of posted; approving re-fires the identical render. The cron path posts without bypass, so the gate is live on the autonomous path for the transformation, talking-head and faceless engines.

  • Blitz review. Generated reels land in a swipe-style approve/reject inbox — you clear the day’s queue in a minute, or hand the gate off per account when you’re ready.

  • Spend caps, two enforcers. A per-account daily cap is checked twice — one in-memory, one durable in Postgres that refuses to spend past the limit — plus a monthly cost throttle.

The virality gate

Scored before it posts.

Opinions don’t gate the queue — measured performance does. The scorer is rule-based and explainable, not a black box.

  • Hooks are scored before posting. In every hook-led format, each variant is rated hook·0.40 + history·0.40 + timing·0.20; the best has to clear a per-account threshold or the batch re-rolls.

  • Virality outranks taste. The recommender learns from approvals and outcomes — when the operator’s preference and the numbers disagree, the numbers win, unless you hard-veto.

  • Analytics close the loop. The monitor agent pulls real per-post engagement every 30 minutes back into the hooks database, steering the next render toward what your audience actually rewarded.

  • Cross-account learning. Signal from one account’s wins is shared into the recipe for the next render — CreatorOS gets smarter across the whole roster, not one handle at a time.

Tokens, the ledger & billing

Metered to the cent, on a ledger you can audit.

CreatorOS Token unit

1 COT = $0.05

Customers see whole tokens; provider settlement is in USD. Charges round up, balances round down — CreatorOS never undercharges or overstates.

  • An append-only, insert-only ledger. Every paid provider call is one immutable Postgres row — a database trigger rejects deletes — split into client wallets and provider pools. Profit is Σ charged − Σ cost, read straight off the table.

  • Per-format receipts. A single pricing source of truth itemizes each render as step receipts, from the Whiteboard format at $0.111 up to a UGC ad at $4.43 — every paid call debited the moment it happens.

  • Two spend gates. An empty wallet returns 402; a dry provider pool returns 503 — the render stops before it can spend money that isn’t there.

  • Top-ups are admin ledger entries. A top-up writes a transaction row and a commission (25%, clamped) sets the token rate — there is no card processor and no self-serve payment path; funding is deliberate and auditable.

  • Bring-your-own-keys routing. A full customer key set can pay its own providers and bypass the wallet on the render path, with telemetry still firing — partial keys fail closed to the wallet.

Multi-tenancy & security

Real tenants today — and an honest map of what’s next.

Per-customer isolation is live. The production auth-hardening pass is staged on its own branch, and we’d rather show you the line than blur it.

Live now

Shipping on the deploy branch

  • Per-customer account & niche isolation — reaching another tenant returns 403.
  • Three-path auth: device-bound JWT, refresh-cookie fallback, internal worker token.
  • Per-user model switching with hard cross-user key isolation via per-task contextvars.
  • Multiple named admins, bootstrapped from env and rotated by redeploy.
  • Encrypted BYOK key handling on the render path (Fernet).
Staged · security branch

Written, not yet merged live

  • Fail-closed 401s everywhere (live still falls back to a dev-admin identity when the terminal secret is unset).
  • Mandatory at-rest secrets in prod — BYOK key and webhook HMAC required, not warn-only.
  • A loopback-bound operator terminal (live still publishes it on the public port).

This split is the real state of the code, not marketing. The hardening exists and is reviewed; it lands on the live branch when it merges. We mark staged work staged.

API · CLI · MCP · deploy

Every surface an operator or an agent needs.

One FastAPI app runs it all, exposes it to your own agents over MCP, and ships to production with a single command.

203
HTTP routes on one FastAPI app
42
MCP tools over stdio
17
Click CLI commands + 2 sub-groups
WebSocket
live dashboard events
What’s on each surface
  • Auth & sessions, billing & wallet, pricing, model prefs, six semantic trigger endpoints, render jobs, accounts & onboarding, library, posts & analytics, reviews, personas, health/meta, and a worker bridge — behind tiered auth deps.

  • setup · providers · generate · post · preview · schedule · library · bio · health · agents · morning · watchdog · shadowban · costwatch · queue · ask · autonomy, plus persona and hypotheses sub-groups.

  • 42 tools your own Claude can call — list_accounts, build_clip_library, post_for_account, research_niche_trends, get_hook_leaderboard, run_morning_routine, scout_niche_feed, run_shadow_ban_check and more.

  • GitHub Actions builds a GHCR image and ships any branch to a single-VPS Docker Compose stack — web + terminal + postgres — with -f confirm=deploy and an alembic dry-run, no merge to main. Three launchd agents bridge the operator’s Mac.

ClaudeKling V3SeedanceVeo 3.1HailuoGPT Image 2Nano BananaElevenLabsRemotionFFmpegDolphin AntyPlaywrightHiggsfieldPostgresFastAPI
Questions, answered straight

What operators ask first.

Do I need to film anything?

No. Run an invented AI persona, or upload photos of yourself once and record one voice sample — CreatorOS renders your personal brand from there. You never film again unless you want to.

Will it post without asking me?

Not until you tell it to. Out of the box, autonomy is off — nothing posts at all. When you switch it on, you can add the per-account approval gate: it renders, scores, and queues, then waits for your yes on every post.

Is my account safe?

Posting goes through a persistent, logged-in anti-detect browser with a residential proxy — the platform sees the same human-looking session every day. No platform API posting, no shared fingerprints, no burst behavior.

What does a video cost?

It depends on the format, and you see it as it happens: faceless and research formats cost cents (the Whiteboard format runs about $0.11); lip-synced talking-head formats cost dollars; a UGC ad runs up to $4.43. Every paid call lands itemized on an append-only ledger, billed in tokens at $0.05 each.

Which platforms does it post to?

Instagram, TikTok, Facebook and YouTube through the same real-browser engine. Platform scope is set per account — an Instagram-only creator never touches TikTok.

Where do trends come from?

From the account’s own warmed feed, read inside its own browser session — plus music sourced only from artists the account actually follows. Not from Reddit threads, hashtag APIs, or someone else’s For You page.

Can I plug it into my own agents?

Yes. The whole thing is a FastAPI app of 203 routes and a 42-tool MCP server, so your own Claude can list accounts, build libraries, research trends, and post — and a 17-command CLI covers the same ground from a terminal.

Pilots open · onboarded by hand, one account at a time

Put the whole engine on your account.

One niche, one handle, one browser profile — and the loop starts turning. Write a sentence about what you post; get back a plan and a per-render price.