池 · the koi pond

Ike runs a fleet of always-on, automated channels — and keeps each one live, monetized, and compliant 24/7.

No streamer. No studio. No human in the loop. The name is the metaphor: Ike (池, "the koi pond") is the calm surface where every channel converges and is watched over — fed by Genryu (源流, "the headwater"), the engine that produces the live signal.

The opportunity

24/7 "always-live" channels — ambient/BGM, gameplay loops, lo-fi, ASMR, radio-style content — are one of the most durable formats on YouTube and the wider streaming web. They accrue watch-hours, ad revenue, and memberships continuously, without a person on camera.

But running one properly is a systems-engineering problem, not a creative one:

Live encoders drift out of spec and trip YouTube's ingestion warnings.
YouTube silently turns monetization off on most new live broadcasts, and the public API exposes no way to turn it back on.
Broadcasts get auto-completed, Content-ID claims land, stream health degrades — all invisibly, at 3 a.m.
Doing this for more than one channel multiplies every failure mode.

Today this is solved by a patchwork of manual babysitting, brittle scripts, and paid "restream" tools that only relay video — none of which manage the broadcast lifecycle, monetization, compliance, and content pipeline an automated channel actually needs.

Ike is the operating system for automated, monetized, always-on channels — built multi-tenant from the ground up.

What Ike is

A multi-tenant control plane plus a per-channel streaming stack. One codebase runs an entire fleet; each channel's identity and credentials live in per-host config, never in the code.

Component	Code name	What it does
Control plane	Ike 池	Central brain: telemetry farm, monetization automation, admin alerting, fleet dashboard, and the API every channel reports to.
Stream engine	Genryu 源流	Per-channel 24/7 FFmpeg pipeline — a shuffled, pre-encoded content pool pushed to YouTube Live over RTMP on a programmable block schedule, a fresh broadcast per block.
Creator Studio	Workshop	The web control panel a creator uses to run their channel — playlists, schedule, branding, settings, insights — no terminal required.
Notification bot	Owl	Per-channel health monitor + Telegram bot: live status, alerts, and one-tap remote recovery.

The economic insight: the marginal cost of the Nth channel is near zero. Onboarding a channel is config + credentials, not new engineering. That's what turns a personal automation into a platform.

What it does today

A working system, live in production across multiple channels — not a prototype.

Streaming & lifecycle

24/7 FFmpeg push to YouTube Live RTMP, looped, stream-copy (no quality loss at broadcast).
Dynamic, creator-editable block schedule; the cron that drives it auto-regenerates on change.
A fresh broadcast provisioned per block via the Data API — clean lifecycle, no fragile keys.

Monetization automation — the hard part

Headed-browser Studio automation drives what the public API deliberately doesn't expose.
YouTube auto-disables monetization on 65–75% of new broadcasts; Ike detects and auto-re-enables every 60s, restoring mid-roll mode & ad settings.
Optional automated mid-roll insertion + license/distribution enforcement.

Compliance & integrity

Every file re-encoded to YouTube's live spec at ingestion — the enforcement point that avoids ingestion trouble.
AI / "altered content" disclosure set centrally and audited per broadcast.
Content-ID claim detection + channel-settings drift alerts.

Content pipeline

Creators drop raw footage in a SharePoint library; Ike syncs, sanitizes, re-encodes, and pools it.
Idempotent and concurrency-safe. (Dropbox/Box on the roadmap.)

Operator & creator surfaces

Creator Studio: timeline-first web UI with a cohesive design system, Stream Insights, and a creator-confirmed feedback loop (an issue isn't closed until the creator confirms it's fixed).
Telegram bots per channel + an aggregated fleet view; dashboard with self-service session re-seed.

Reliability

Health monitor with 15+ independent checks (process, schedule, resources, YouTube-side status, monetization, stream health, Content-ID, telemetry liveness).
Automatic recovery of dead broadcasts; self-healing watchdogs; monitor can't be blinded by what it watches.

Multi-tenant by per-host config; push-to-deploy across the fleet (sync → compile → restart → sanity-check → alert). Secrets never in the repo.

Why it's defensible

The monetization moat. Re-enabling monetization on live broadcasts is not possible through any public API — it needs reliable, maintained browser automation against a hostile, shifting UI. We run it centrally across the fleet. It's the hardest, highest-value capability, and it directly drives revenue.

Depth, not relay. Restream-style tools move pixels. Ike manages the whole channel: lifecycle, monetization, compliance, content spec, recovery, insights. The difference between a cable and an operator.

Multi-tenant from day one. The architecture, deploy pipeline, and config model already run a fleet. Tools built for a single human streamer don't generalize to "operate N channels for N customers."

Operational know-how compounds. Every Studio-DOM change, ingestion quirk, and policy shift is captured as maintained automation. The catalog of "what breaks and how we auto-fix it" is the real IP.

Traction & status

Live in production across [ N ] channels today (reference: This Tired Toad, thatLazySnail), on the current multi-tenant architecture.
Product maturity: beta (v0.06) — multi-tenant infrastructure landed; second tenant live on the production architecture.
[ X ] hours streamed · [ Y ] cumulative watch-hours · [ $Z ] monetization to date.
Infra cost [ $ / channel / mo ] (commodity cloud VM + storage) vs. a target subscription of [ $ / channel / mo ] — the unit economics are the pitch.

Honest framing for the deck: the strength is a working, defensible system with near-zero marginal cost per channel — not (yet) a large user base. Lead with technology + unit economics + the path to self-service, and fill the figures above before sharing.

Market

The creator economy is large and growing; "faceless" / automated / always-on channels are a fast-growing, under-tooled segment — because they're a systems problem most creators can't solve.
Adjacent spend already exists: creators pay for multistreaming (Restream, Castr, StreamYard), membership/OTT tooling (Uscreen), and editing/automation — but none operate an automated channel end to end.
[ TAM / SAM / SOM ] — size from the segments above with stated assumptions.

Business model

SaaS per channel — a monthly subscription per managed channel; gross margin is a function of how cheaply we run the Nth channel.
Monetization upside share (optional tier) — because Ike measurably increases realized ad revenue by keeping monetization on, a rev-share tier aligns incentives.
Self-serve → managed ladder: a published onboarding runbook for self-serve, white-glove fleet management for larger operators.

Roadmap

Horizon	Milestone
Now (v0.06)	Multi-tenant production; central monetization + telemetry + compliance automation; creator-confirmed feedback loop; cohesive Studio design system.
v0.10	Second tenant fully live under owner-supplied credentials; two-tenant deploy proven end to end.
Platform diversification	Multi-provider simulcast — a provider-agnostic lifecycle interface with per-platform adapters + hub-and-spoke RTMP fan-out from the channel node. Design is done and research-backed: start with Twitch (+ reach-only Rumble/Trovo), excluding platforms hostile to looped-as-live. Removes single-platform dependence and takedown risk — a core strategic driver.
v0.50	Self-service onboarding — a new operator stands up a channel from a runbook + helper scripts, no engineering. The inflection from product to platform.
v1.0	First paying tenant outside the founder; billing, support, SLOs.
Beyond	Mobile/PWA control, pluggable content repos (Dropbox/Box), premiere scheduling, channel-art automation, deeper analytics.

Competitive landscape

They do	Ike does
Restream / Castr / StreamYard — relay one human's live video to many destinations.	Operate an automated channel with no human: lifecycle, monetization, compliance, recovery — and (roadmap) simulcast on top.
OBS + manual scripts — what a solo automated-channel operator cobbles together.	The maintained, multi-tenant, self-healing version of exactly that — including monetization automation a script can't keep alive.
OTT / membership platforms (Uscreen, etc.) — host & monetize VOD/live you produce.	Sit upstream: actually run the channel 24/7 where the audience already is.

The wedge: nobody else automates the monetization and compliance of always-on channels at fleet scale. That's the hard, valuable, defensible middle Ike owns.

The stack — for technical diligence

DigitalOcean (Ubuntu 24.04) · systemd · FFmpeg · Python · FastAPI · Playwright / headed-Chromium under Xvfb · YouTube Data API v3 + Studio automation · Microsoft Graph (SharePoint) · Telegram · nginx · GitHub Actions CI/CD.

Multi-tenant by host.json; push-to-deploy across the fleet; secrets never in the repo.

The ask

[ Raise amount · use of funds · milestones ]

Suggested framing: capital converts a working, defensible system into a self-service platform — fund (1) self-service onboarding, (2) multi-platform simulcast, (3) go-to-market for the faceless-channel segment.