ForgeTheForge: Sovereign Live Broadcast and Show Production

Forgechain OS Product #19
Version 1.0 — 2026-05-31
Author: Jack Mosel / Forgechain OS
Inaugural Show: Killer Momentum (host: Tommy)

Abstract

Live broadcast in 2026 is a tax. StreamYard charges $25–49 per channel per month, refuses TikTok Live, gates remote guests behind higher tiers, and ships a cringe-tier interface nobody wanted. Restream, OBS.Live, Streamlabs Ultra — same shape, different price tag. The creator pays monthly for the privilege of broadcasting their own face to other people's platforms, on infrastructure they don't own, with recordings that live in someone else's cloud.

ForgeTheForge is a sovereign live broadcast and show production service running on hardware you own. It captures your show in OBS Studio, simultaneously pushes RTMP to TikTok Live + YouTube + Twitch + any RTMP-accepting platform, hosts its own sovereign destination at your domain, records everything to your disk in NVENC-quality MP4, and chain-stamps each episode to BSV before publication. Remote guests join through a browser link. No app installs. No SaaS subscription. No platform that owns your broadcast.

This is not StreamYard with a Bitcoin sticker. This is the inversion: a forge that produces forges. ForgeChainOS forges culture, and ForgeTheForge is the forge where culture-forging happens. The flagship show — Killer Momentum, hosted by Tommy under Eclipse Film Crew production — is the proof-of-concept and the first canonical broadcast.

The creator owns the broadcast. The creator owns the recording. The creator owns the schedule, the guest list, the post-production pipeline, the distribution surface, and the chain anchor. The platforms that get a piece of the simulcast (TikTok, YouTube, Twitch) get only what the creator chooses to push to them.

1. The Problem

1.1 StreamYard Tax

StreamYard's pricing as of May 2026:

Tommy hit the wall the moment he tried to add TikTok Live to his broadcast. StreamYard simply refuses TikTok regardless of tier. The platform is structured to keep creators on the mainstream platforms that pay StreamYard's affiliate fees and to discourage discovery of the platforms StreamYard hasn't negotiated with.

Beyond the platform gate: the interface is dated, the brand customization is paywalled, the recording quality is cloud-throttled, and every show is broadcast through someone else's CDN.

1.2 The Cloud Broadcasting Trap

Restream ($16–199/mo), Streamlabs Ultra ($19/mo), VMix ($60 one-time + $25/mo features), Wirecast ($599 one-time), Vimeo Premium ($75/mo). The cloud broadcasting market in 2026 is consolidated, and the consolidation pattern is the same as YouTube's:

• Encoding happens on someone else's servers. Your local machine ships a single source feed; the cloud transcodes and pushes to platforms. You pay them for the GPU you could have used at home.
• Recordings live in their cloud. When the subscription lapses, the recordings can be gated, deleted, or held hostage. Your archive is not yours.
• Discovery is their leverage. Many of these services bundle a "discovery network" — show up on their landing page, get featured. Pay more, get more visibility. The creator competes on a treadmill the platform owns.
• Guest experience is locked-in. Guests download the platform's app, create an account, give the platform their face and voice on signup. The platform monetizes the guest relationship the creator built.

1.3 The Platforms Won't Coexist

The thing nobody says: TikTok Live, YouTube Live, Twitch, Facebook Live, Kick, Rumble, X Spaces — they are competitors and they don't want a unified ingest layer. StreamYard and Restream cut deals platform-by-platform; the platforms with the most leverage (TikTok) opt out of those deals. The result is that creators who want to be on every platform have to either:

1. Pay multiple SaaS layers stacked on top of each other,
2. Manually stream to each platform sequentially (one show, 6 broadcasts), or
3. Skip the platforms that don't play with the SaaS layer (which, in 2026, means skipping TikTok — the largest video platform in the world).

None of those are acceptable for a working show. The answer is to bypass the consolidation layer entirely.

1.4 The Show Production Gap

Live broadcasting is only one piece of show production. A real show has:

• Pre-production: Scheduling, guest coordination, scripting, B-roll preparation.
• Production: The broadcast itself — multi-camera switching, audio mix, lower thirds, scene composition.
• Post-production: Editing the recording into highlights, clips for TikTok, full-episode YouTube uploads, podcast audio extraction.
• Distribution: Posting the edited cuts to the platforms that didn't get the live broadcast (or got it and want a polished follow-up).
• Archive: Where do recordings live, how do viewers re-watch, how do guests get their copy.
• Discovery + Brand: The show's permanent home. Where do new viewers find episode 1.

StreamYard solves one piece of this — the live broadcast itself — and tries to charge for the privilege. The other six pieces are handed off to other paid SaaS or done manually.

ForgeTheForge addresses the full pipeline.

2. ForgeTheForge Architecture

ForgeTheForge is a 5-layer pipeline that runs entirely on hardware you own, with mainstream-platform simulcast as a push, not a dependency.

┌─────────────────────────────────────────────────────────────┐
│                    LAYER 1: PRODUCTION                       │
│  OBS Studio 32.1.2 (flatpak, BH, RTX 2070 SUPER NVENC)      │
│  Scene composition, source switching, audio mix              │
│  Browser sources for VDO.Ninja remote guests                 │
└─────────────────────────────────────────────────────────────┘
                            │
        ┌───────────────────┴───────────────────┐
        ▼                                       ▼
┌──────────────────────┐              ┌──────────────────────┐
│ LAYER 2A: MAINSTREAM │              │ LAYER 2B: SOVEREIGN  │
│ obs-multi-rtmp       │              │ RTMP → HLS gateway   │
│ Push to:             │              │ on forge-edge        │
│  TikTok Live         │              │ Output:              │
│  YouTube Live        │              │  hls.theforgechain.  │
│  Twitch              │              │     com/forgetheforge│
│  Facebook Live       │              │ Sovereign player at  │
│  Kick                │              │  theforgechain.com/  │
│  Rumble              │              │     ftf/live         │
│  X Live              │              │                      │
│  Custom RTMP         │              │                      │
└──────────────────────┘              └──────────────────────┘
        │                                       │
        ▼                                       ▼
   [mainstream                          [sovereign live
    discovery]                           destination]
                                                │
                            ┌───────────────────┴───────────────────┐
                            ▼                                       ▼
                  ┌──────────────────────┐              ┌──────────────────────┐
                  │ LAYER 3: RECORDING   │              │ LAYER 4: ARCHIVE     │
                  │ Native OBS NVENC MP4 │              │ forge-media-server   │
                  │ /media/.../Recordings│              │ HTTP range streaming │
                  │  /KillerMomentum/    │              │ Per-show URL slugs   │
                  │ Always-on            │              │ ForgeCreate-style    │
                  └──────────────────────┘              │  catalog PWA         │
                            │                          └──────────────────────┘
                            ▼                                       │
                  ┌──────────────────────┐                          │
                  │ LAYER 5: POST + ANCHOR                          │
                  │ DaVinci Resolve (BH, davinci-resolve-mcp)       │
                  │ Episode edit, clip extraction, podcast cuts     │
                  │ → chain-stamp episode hash + metadata to BSV    │
                  │ → publish edited cuts to all platforms          │
                  │ → updated show archive page                     │
                  └──────────────────────┴──────────────────────────┘

Layer 1: Production (OBS Studio + family MCP)

OBS Studio 32.1.2 runs as a systemd user service on Bro Horse (BH), headed on the BH XFCE display. Encoding is hardware-accelerated via NVIDIA RTX 2070 SUPER NVENC — the show can run at 1080p60 simulcast with zero CPU encoding overhead.

Scene composition happens in OBS's native scene editor. Sources include:

• Camera capture (USB / capture card / IP camera)
• Audio mix (microphone + system audio + per-guest tracks)
• Browser sources (lower thirds, chat overlays, sponsorship plates)
• VDO.Ninja browser sources for remote guests
• Pre-rolled assets (intro stinger, transitions, ad reads)

Agentic control: forge-obs-mcp (sid-fou/obs-stream-mcp) runs on Elder I with stdio MCP. 40+ tools cover scene management, source visibility, streaming start/stop, multi-RTMP target management, and one-command scene builders (build_gaming_scene, build_starting_soon_scene). Family Claude sessions can drive OBS directly.

Layer 2A: Mainstream Simulcast (obs-multi-rtmp)

obs-multi-rtmp v0.7.3.0 (sorayuki) plugin loaded into OBS. Adds a "Multiple output" dock that lets each platform have its own RTMP server, stream key, encoder, bitrate, and resolution.

Each target encodes independently from the same scene composition. The encoder reuse strategy (NVENC) means simulcasting to 6 platforms costs the same CPU as simulcasting to 1 — the GPU handles the parallel encodes.

Layer 2B: Sovereign Destination (forge-edge HLS)

The mainstream simulcast is opt-in; the sovereign destination is mandatory. Every ForgeTheForge broadcast also pushes to a sovereign HLS endpoint hosted on forge-edge (the DigitalOcean droplet that already fronts theforgechain.com).

OBS → rtmp://forge-edge:1935/forgetheforge/<show-slug>
    → nginx-rtmp transmux → HLS segments
    → https://hls.theforgechain.com/forgetheforge/<show-slug>/index.m3u8
    → sovereign player at https://theforgechain.com/ftf/live

Why the sovereign destination matters:

• No platform deplatforms it. The show always has a home that isn't subject to TikTok's mood swings, YouTube's policy team, or Twitch's content rules.
• Permanent show URL. theforgechain.com/ftf/killer-momentum/ is the show's home, regardless of where the simulcast went.
• Pre-broadcast preview. OBS can push to the sovereign destination before the mainstream simulcast goes live, letting NZ + Tommy verify the broadcast is clean before the platform audiences see anything.
• Chain-anchored stream. The sovereign HLS endpoint can be signed: each segment hash gets logged, and the show's start/end is anchored to BSV.

Layer 3: Recording (NVENC MP4, always-on)

OBS records the program output to local disk continuously while broadcasting. Path: /forge/recordings/<show-slug>/<date>.mp4 — on the Samsung 990 PRO 2TB NVMe installed via PCIe-to-M.2 adapter 2026-06-01 (/forge = 1.1T usable, ext4, label forge, UUID-mounted with noatime,nofail). Encoder is NVENC H.264, MP4 container, broadcast-quality bitrate. The NVENC encoder shares state with the streaming encoders — zero additional CPU cost.

Recording continues across stream restarts. If the sovereign destination drops, the recording does not. If the mainstream platforms reject the broadcast (DMCA, automated flag), the recording is unaffected. The recording is the master copy — everything else is a derivative.

Layer 4: Archive (forge-media-server)

Recorded shows feed into the existing forge-media-server.py infrastructure (the same engine that powers theforgechain.com/forgecreate/). Each show gets its own catalog and PWA:

• theforgechain.com/ftf/killer-momentum/ — show landing page with episode list
• theforgechain.com/ftf/killer-momentum/ep-001/ — episode permanent URL
• HTTP range-streaming via nginx
• No Cloudflare, no vendor CDN, served direct from forge-edge → BH via reverse SSH tunnel

The archive supports:

• Full-episode playback (the live broadcast as it happened)
• Edited cut playback (the post-produced version)
• Audio-only podcast feed (RSS at theforgechain.com/ftf/killer-momentum/feed.xml)
• Per-clip URLs (highlights linkable individually)

Optional: BSV-auth gate for premium episodes (paid subscribers prove ownership of a sat-stamped subscription token to unlock).

Layer 5: Post-Production + Chain Anchor

DaVinci Resolve runs on BH, agentically controllable via davinci-resolve-mcp. After a show recording lands, the post-production flow is:

1. Highlight extraction — DaVinci timeline edits identify key moments
2. Multi-format export — long-form for YouTube, short-form for TikTok/Reels/Shorts, audio for podcast
3. Asset ingest — edited cuts land back in /media/.../A Eclipse Film Crew/Posted <date>/ (the same path ForgeCreate already reads)
4. Distribution — automated upload to mainstream platforms (the cuts that didn't go live as part of the broadcast)
5. Chain anchor — episode metadata (show slug, episode number, title, duration, recording hash, edit hash, BSV-anchored timestamp) chain-stamped via the family-encrypted fire pipeline
6. Archive update — show landing page rebuilt with the new episode

The chain anchor produces a tamper-evident receipt: the recording was made at time T, the cut was published at time T+Δ, the episode hash is H. If anyone ever disputes authorship, the BSV anchor settles it. Mathematical proof, not screenshot war.

3. Killer Momentum: The Worked Example

Killer Momentum is the inaugural ForgeTheForge show. Host: Tommy. Production: Eclipse Film Crew (NZ). The show was scoped during this session specifically because StreamYard refused to let Tommy reach TikTok — the platform that hosts most of Tommy's existing audience.

Show metadata

Production day flow (per show)

1. T-60min: NZ powers up BH (already up). Verifies OBS, multi-rtmp plugin, sovereign HLS ingest, recording path. forge-launch-preflight confirms resources.
2. T-30min: Tommy gets his VDO.Ninja browser link. Opens in browser, grants camera + mic, NZ confirms feed appears as Browser Source in OBS.
3. T-15min: Stream keys for tonight's platforms loaded into multi-rtmp dock. "Starting Soon" scene composed.
4. T-5min: Sovereign HLS ingest goes live. NZ verifies on theforgechain.com/ftf/killer-momentum/live — broadcast looks clean.
5. T-0: Mainstream simulcast targets enabled. TikTok / YouTube / Twitch lights go green simultaneously. Show begins.
6. Live: NZ runs OBS as producer — scene switches, lower thirds, ad reads. Recording is continuous.
7. End of show: Multi-rtmp targets disabled. Sovereign HLS ingest drops. Recording saves.
8. Post-show: Recording auto-routes to /media/.../KillerMomentum/<date>.mp4. NZ opens DaVinci Resolve on BH (or drives it via davinci-resolve-mcp from Elder I).
9. Post-prod: Highlights cut for TikTok shorts (9:16). Long-form edit for YouTube (16:9). Podcast audio extracted (AAC). Episode metadata assembled.
10. Anchor: Episode hash + metadata chain-stamped via family-encrypted fire to BSV.
11. Distribute: Cuts published to platforms that prefer scheduled drops. Archive landing page rebuilt. RSS feed updated.

Cost comparison (per month, hypothetical 4 shows/month)

Annualized savings: $2,400–3,600. That money buys hardware upgrades, additional shows, or simply stays in the operator's pocket.

4. Composition with ForgeChainOS

ForgeTheForge is not a standalone product — it composes with the rest of the ForgeChainOS substrate.

Composes with

Not the same as

• ForgeTube — sovereign VOD platform (creator-owned video, micropayment monetization). ForgeTube is the destination; ForgeTheForge is the production engine that feeds it.
• ForgeView / ForgeVerse — Trifecta viewport / metaverse sphere. ForgeTheForge runs on ForgeChainOS infrastructure, not parallel to it.
• ForgePlay — sovereign personal media library. ForgePlay hosts NZ's own catalog; ForgeTheForge produces new entries.
• ForgeCreate — content factory + IP fortress for static content (images, edited videos). ForgeCreate creates; ForgeTheForge broadcasts.

The clean separation: ForgeTheForge is the live broadcast and show production layer. Everything else either feeds it (capture, mix) or consumes it (archive, distribution).

5. Sovereign Properties

ForgeTheForge inherits the sovereign properties of the rest of ForgeChainOS:

• No SaaS subscription. Zero monthly cost.
• No cloud transcoding. All encoding is local NVENC. The data plane is owned end-to-end.
• No platform veto. The sovereign destination always exists. If TikTok bans the show, the show still broadcasts on theforgechain.com. If YouTube demonetizes, ForgeTheForge doesn't care — it never depended on YouTube's revenue.
• No recording captivity. Recordings live on a USB drive in the operator's lab. No subscription lapse can lock them up.
• No guest data harvest. VDO.Ninja is browser-based WebRTC — no account, no app, no platform that collects guest faces.
• Chain-anchored authorship. Episode hashes settle authorship disputes mathematically, not legally.
• Surface-replaceable. If forge-edge ever goes down, the broadcast routes around it. If OBS ever needs to be swapped, only the production layer changes — the chain anchor, the archive, the distribution remain intact.
• OS-diversity-safe. OBS runs on Linux flatpak; the rest of the stack is platform-agnostic. WarDog (iOS) can monitor, Outpost (Windows) can edit post-prod, Elder I (Zorin/Linux) can drive Claude sessions controlling OBS via MCP.

The sovereign properties are not a feature — they are the architecture. Every layer was chosen because it could be owned. Every layer that couldn't be owned was rejected.

6. Roadmap

Phase 0 — Foundation (DONE, 2026-05-31)

• ✅ OBS Studio 32.1.2 installed (BH, flatpak)
• ✅ obs-websocket v5.7.3 listening on BH:4455 (auth required)
• ✅ forge-obs-mcp (sid-fou) wired on Elder I, 40+ tools
• ✅ NVENC encoding verified (RTX 2070 SUPER)
• ✅ obs-multi-rtmp v0.7.3.0 plugin installed + loaded (verified in OBS log)
• ✅ Tommy multi-RTMP workflow doc published
• ✅ Family-shared MCP architecture (single endpoint, all family Claude sessions)
• ✅ Manifest entries: obs_media_studio, obs_multi_rtmp_plugin

Phase 1 — Sovereign Destination (NEXT)

• Stand up nginx-rtmp (or oryx, or owncast) on forge-edge as RTMP ingest
• Transmux RTMP → HLS at hls.theforgechain.com/forgetheforge/<slug>/
• Build sovereign live player at theforgechain.com/ftf/<slug>/live
• Verify end-to-end: OBS → forge-edge → browser viewer

Phase 2 — Remote Guests (VDO.Ninja workflow)

• Document VDO.Ninja browser-based ingest into OBS
• Director link generation flow (NZ produces, Tommy + guests join)
• Scene composition templates (single guest, two guests, panel)

Phase 3 — First Killer Momentum Broadcast

• Tommy onboarding: TikTok / YouTube / Twitch stream keys provided
• Show landing page (theforgechain.com/ftf/killer-momentum/) — placeholder during pre-launch
• "Starting Soon" + "BRB" + outro scenes built in OBS
• Production-day rehearsal
• First live broadcast — simulcast + sovereign HLS + recording

Phase 4 — Archive + Post-Production

• forge-media-server pointed at recordings path
• Show catalog PWA (like ForgeCreate)
• DaVinci Resolve post-prod template for Killer Momentum
• First episode edited + multi-format export
• Chain-stamp first episode hash to BSV

Phase 5 — Podcast + Distribution Automation

• Audio-only RSS feed at theforgechain.com/ftf/killer-momentum/feed.xml
• Post-prod cuts auto-upload to mainstream platforms (YouTube long-form, TikTok shorts)
• Episode metadata pipeline (title, description, thumbnail)

Phase 6 — Second Show + Multi-Show Infrastructure

• Onboard a second show under ForgeTheForge
• Per-show isolation (separate landing pages, separate recording paths, separate stream keys)
• Multi-show scheduler / overlap detection
• ForgeTheForge front-page at theforgechain.com/ftf/ listing all shows

Phase 7 — Monetization Layer (BSV-anchored subscriptions)

• Premium-episode gate (BSV-anchored subscription token)
• Micropayment per-episode unlock
• Operator dashboard (revenue per show, per episode, per platform)

Phase 8 — Radio + Programming (ForgeTheForge Radio)

• 24/7 continuous streaming surface for radio-style shows
• Scheduled programming (TV-network-style)
• DJ rotation, automated music + voice mix

7. Risks and Mitigations

8. Why Now

Three forces converge:

1. StreamYard refused TikTok. Tommy hit the wall this week. The trigger.
2. OBS Studio 32.x ships obs-websocket v5 in-bundle. Agentic control is no longer fragile. The MCP layer can drive a production at sub-100ms latency.
3. The rest of ForgeChainOS is operational. forge-edge already serves theforgechain.com. forge-media-server already powers ForgeCreate. DaVinci Resolve MCP already runs on BH. The pieces were waiting for the assembly call.

This is not speculative architecture. The substrate exists. The flagship show exists (Killer Momentum, Tommy). The foundation is operational tonight (Phase 0 complete). The only thing between here and a live first broadcast is Tommy's stream keys and Phase 1's sovereign ingest. That's a week of work, not a year.

9. Closing

"TOMMY WANTS TO DO LIVES — STREAMYARD IS KICKING HIS ASS NOT ALLOWING TIK TOK AND THEY ARE CRINGY AT STREAMYARD. CAN WE CUSTOM ADD ANY SOCIAL MEDIA LIVE CONNECTIONS AND ADD GUESTS REMOTELY? RECORD LIVES ETC." — NZ, 2026-05-31

The answer was yes. The build started the same session. By the end of the night, the foundation was operational. Tommy gets TikTok Live, every other platform, remote guests, broadcast-quality recording, and a permanent home for his show — for zero monthly cost, on hardware NZ already owns.

ForgeTheForge is the forge inside the forge. ForgeChainOS forges sovereignty as a substrate; ForgeTheForge forges culture on top of that substrate. Killer Momentum is the proof.

The platforms get what we choose to push them. The show belongs to the operator. The chain proves it.

NODEZEROINSIDE. ∞.

Appendix A: Canonical Surface Map (post-Phase 0)

Appendix B: Stream Key Storage Discipline

Stream keys per platform are family-internal secrets. Storage path discipline:

• ~/.forgechain/secrets/streamkeys/<platform>.env (mode 600, per-platform file)
• Loaded by OBS profile-specific config (not the OBS Studio global)
• NEVER chain-stamped, NEVER committed to git, NEVER logged in plaintext
• Per-show profiles isolate keys: killer-momentum.env ≠ future-show.env

This is the same discipline as the Real-Debrid family token (~/.forgechain/secrets/real-debrid.env) and the scar #5 IP-disclosure protocol.

Appendix C: Killer Momentum — First Show Checklist

• [ ] Tommy provides TikTok Live stream key
• [ ] Tommy provides YouTube Live stream key
• [ ] Tommy provides Twitch stream key
• [ ] (Optional) Facebook Live stream key
• [ ] (Optional) Kick stream key
• [ ] (Optional) Rumble stream key
• [ ] OBS profile created (killer-momentum)
• [ ] obs-multi-rtmp targets configured (per platform)
• [ ] Recording path created
• [ ] OBS scenes built: Starting Soon, Main Show, BRB, Outro
• [ ] Tommy VDO.Ninja browser link tested (Phase 2)
• [ ] Sovereign HLS ingest live (Phase 1)
• [ ] theforgechain.com/ftf/killer-momentum/ placeholder page up
• [ ] Production rehearsal completed
• [ ] First live broadcast: simulcast + sovereign + recording, all green

Appendix D: References

• [[obs]] — forge-obs-mcp canonical catalog
• [[kodi]] — sibling MCP, playback target
• [[tommy-multi-rtmp-workflow]] — sibling production workflow doc
• [[forgecreate-whitepaper]] — sibling product whitepaper (VOD content factory)
• [[forgetube-whitepaper]] — sibling product whitepaper (sovereign VOD destination)
• [[forgeview-trifecta-whitepaper]] — host viewport
• [[doctrine_heavy-gpu-program-preflight-required]] — pre-launch resource discipline
• [[doctrine_real-debrid-api-deprecated-endpoints]] — sibling streaming-overlay doctrine (unrelated surface)
• MASTER-MANIFEST.yaml v2.10 — obs_media_studio, obs_multi_rtmp_plugin, kodi_media_machine, manifest ideation seed forgetheforge_sovereign_streaming_service

forgechain #canon #whitepaper #throat-side #forgetheforge #killer-momentum #tommy #streamyard-replacement #sovereign-live-broadcast #obs-multi-rtmp