ProbablyTV

A television station made from your own media library --- programmed by an editorial system rather than a playlist editor.

ProbablyTV is an experimental, self-hosted television system for people who have accumulated a large video library and then discovered that having media is not the same thing as actually watching it.

Traditional media servers are very good at answering:

What do you want to watch?

ProbablyTV starts from a different question:

What if I don't want to decide every time?

The aim is to create a small broadcaster that feels alive: channels have identities, programmes have editorial briefs, scheduling is intentionally a little fuzzy, and an LLM-based Station Program Committee can select suitable material from the catalogue in context.

The North Star is simple:

ProbablyTV should feel as if a small broadcaster is actively operating somewhere.

If you want certainty and manually constructed virtual channels, projects such as Tunarr, ErsatzTV and dizqueTV already solve that problem well. ProbablyTV is exploring something else: a station that can surprise you.

A large personal video library creates an unexpected problem: choice becomes work.

You may own years of television series, films, documentaries, concerts, home videos and miscellaneous material, yet rarely watch much of it because finding something, deciding what fits the moment, locating the correct episode and starting playback requires more effort than simply opening a streaming service.

ProbablyTV tries to move that work away from the viewer.

The system should be able to understand a catalogue well enough to create channels and programme blocks that are useful without requiring every item to be manually scheduled. AI can assist with recognition, tagging, indexing and contextual understanding. An editorial LLM can make programme choices. A separate video engine remains responsible for the decidedly non-magical work of decoding and streaming media.

The intelligence belongs around playback, not inside the decoder.

ProbablyTV separates several concepts that conventional playlist-based systems tend to collapse together.

The Station Soul describes the durable identity of the broadcaster: how it behaves, what kind of station it believes itself to be, and how it should react when more specific instructions are unavailable.

A channel can refine that identity for a particular audience or purpose without redefining the whole station.

A Show Brief describes approximately what a programme block should do, in human editorial language rather than as a fixed list of media files.

For example, a schedule might contain conceptual blocks such as:

14:00–16:00  Wonderful Nature
16:00–17:00  Stupid Animals in Nature
17:00–18:00  Don't Choke on Dinner — Sitcoms

The schedule determines when the show exists. The Show Brief explains what kind of show it is. The Station Program Committee decides what actually airs.

The Station Program Committee is the editorial layer. It can consider programme intent, catalogue knowledge, continuity, recent selections, seasons, weather, occasions and other context when choosing material.

This is deliberately different from a deterministic scorer with some randomness added. A scorer can rank candidates. An editorial actor can make a choice for a reason that was not anticipated when the scoring model was written.

Video does not fit a clock as neatly as radio. Programmes have inconvenient runtimes, and forcing exact boundaries encourages truncation, filler and awkward rejection of otherwise excellent choices.

ProbablyTV therefore treats scheduled times as target windows or anchors. A suitable programme may start a little early or run a little late within configured tolerances. Short interstitial items can occasionally help bridge gaps, but content fit remains more important than clock perfection.

ProbablyTV does not require an LLM to sit in the playback path continuously.

The LLM is useful when there is an editorial decision to make:

• understanding or enriching catalogue metadata;
• choosing programme material;
• interpreting a Show Brief;
• reacting to Station Context;
• preparing continuity text;
• deciding how one programme should follow another;
• finding an unexpected but defensible connection between items.

Once a 47-minute programme is playing, the Station Program Committee does not need to spend 47 minutes thinking about it.

The station should be thinking when there is something to think about.

Playback, decoding, streaming, session handling and client capability negotiation belong to conventional deterministic software.

This distinction matters for reliability, architecture --- and power consumption.

One of the first reasonable questions about an AI-assisted media system is whether running a local LLM means running an expensive GPU at high power continuously.

An early real-world measurement from Subwave Radio, the working radio system that is currently acting as a research platform for several ProbablyTV concepts, suggests that this does not have to be the case.

Power was logged using a Shelly power meter at five-minute intervals. The dataset contains 8,641 measurements covering 19 July through 19 August 2026.

Daily energy consumption was calculated by trapezoidal integration of the measured power signal. This was used instead of relying on the device's accumulated energy counter because measurement gaps occasionally caused that counter to reset.

Across the complete measurement period, average consumption was:

• 2.068 kWh/day
• approximately 86 W continuous average power

Subwave Radio switched to persistent local LLM availability on 9 August 2026. Comparing normal days before and after that change gives:

Period Days Average kWh/day Average continuous power

Before: 20 Jul -- 8 Aug 20 2.048 85.4 W After: 10 Aug -- 18 Aug 9 2.046 85.2 W

The difference is approximately -0.003 kWh/day: effectively zero at the resolution and conditions of this field measurement.

This does not mean that LLM inference consumes no power. Earlier instantaneous measurements on this installation showed approximately 76--96 W while idle and roughly 222--338 W during active inference.

The important observation is duty cycle.

Inference peaks are short. Radio playback then continues for minutes without requiring the model to remain busy. Across an entire day, those short peaks were not sufficient to produce a measurable increase in average daily energy use compared with the preceding period.

The migration day itself, 9 August, consumed approximately 2.67 kWh. The following day reached approximately 4.10 kWh.

Those days involved migration and testing activity and do not resemble the subsequent operating pattern. They are therefore not evidence of steady-state LLM cost --- although they may be excellent evidence that an enthusiastic system administrator consumes more electricity than an idle AI.

This is a field observation from one installation, not a general benchmark for local AI hardware.

The defensible conclusion is:

In this installation, moving the station to persistent local LLM inference produced no measurable increase in average daily energy consumption during normal operation.

Different models, GPUs, inference rates, workloads and server configurations will produce different results.

For ProbablyTV, however, the measurement supports an important architectural assumption: local AI does not imply continuous AI inference. An event-driven editorial system can remain available around the clock while spending most of its time doing very little.

Video decoding and transcoding will have their own energy costs and should be measured separately. They should not be confused with the cost of the editorial intelligence layer.

ProbablyTV is greenfield, but some of its ideas are already being exercised by a working sibling system: Subwave Radio / WitWisdom Signal.

The radio has become a useful laboratory because it combines programme scheduling, music selection, DJ personas, Show Briefs, skills, handoffs and local LLM inference in a system that runs for real listeners rather than only in design documents.

One particularly useful discovery is that less prompting can sometimes produce more convincing media.

When personas receive a coherent station environment, current programme context and enough freedom, a small local model can produce continuity that was never explicitly scripted: recurring jokes, station gossip, accidental characters and references that cross programme boundaries.

A coffee machine making strange noises can become a philosophical coffee machine arguing with a refrigerator. A listener selected for a fictional giveaway can reappear the following morning after a night in which no DJ talk was generated. A presenter can casually inherit an absurd event from the previous show without explaining the joke to listeners who just tuned in.

The important part is not the specific joke. It is that the system can create the conditions in which such continuity emerges.

A more detailed field report is available in the project documentation:

• docs/WitWisdom_Small_LLM_Living_Radio.md

Continued Subwave Radio experiments exposed two opposite failure modes that are directly relevant to ProbablyTV.

With too little meaningful context, a local presenter model still has to say something. Cold starts then tend to converge on safe generic material: light through a window, the room, silence, weather, morning, coffee or some arbitrary object nearby. Once such filler enters recent history it can reinforce itself.

With too much persistent context, the opposite happens. A single injected joke about a ceiling fan believing it was an aircraft propeller became successful emergent continuity, crossed show boundaries, survived an operational mixer restart and then kept being supplied to unrelated presenters until it became a semantic attractor.

This suggests that station context needs a lifecycle rather than merely a memory store:

• inject fresh optional context;
• let editorial systems use or ignore it;
• allow useful continuity to reinforce it temporarily;
• let it decay;
• provide an operator-level way to forget/purge it when necessary.

Too little context produces generic filler. Too much long-lived context produces semantic lock-in.

The aim is not to script a station story. A context seed may be ignored, misunderstood inside the fictional invention space, carried through a handoff, or disappear completely. The important architectural property is regulated context flow.

Or, from the radio experiment:

The station is, by design, very good at emergent continuity --- that's a feature, not a bug. What's missing is any way to say "this bit is done".

This also strengthens the case for a future Station Context input/API. Such an interface is not merely a storytelling feature; it is a way for operators, schedules or sidecars to provide fresh semantic material when the station would otherwise be context-starved.

The radio experiments also expose an important boundary for ProbablyTV.

A small model can be particularly entertaining when it receives little information but is still asked to say something. It fills the empty space. In a fictional station world that can be a feature.

It must not become the source of operational truth.

ProbablyTV should therefore maintain a strong distinction between hard facts and invention space.

Hard facts include things such as:

• what media item is actually scheduled;
• which file represents that item;
• episode and continuity order where order matters;
• playback state;
• access and audience policies;
• whether audio is actually present;
• what the deterministic timeline says will happen next.

Editorial invention can include things such as:

• station atmosphere;
• continuity language;
• jokes and recurring fictional incidents;
• presenter relationships;
• gossip within the fictional station world;
• playful explanations and transitions.

Generated continuity may embellish deterministic timeline facts. It must not invent them.

The LLM may say:

Apparently Programming has decided we need another hour of this.

But Programming, not the LLM, determines what actually airs.

LLMs do not only respond to the meaning of the context they receive. The shape and volume of that context also influence the result.

This matters in an editorial system.

If one candidate programme has a title and two sentences of metadata while another arrives with several thousand words of subtitles, synopsis and analysis, the second item must not become editorially more important merely because it occupies more of the model's context window.

The same applies to mixed sources. A verbose metadata provider, language, analyser or library should not silently receive more editorial weight than a concise one.

Source verbosity must never become editorial weight by accident.

ProbablyTV should therefore treat prompt context as a limited conditioning budget, rather than simply concatenating everything known about every candidate.

Before information reaches the Station Program Committee, the system should where appropriate: - normalize comparable sources to comparable levels of detail; - summarize or truncate disproportionately verbose material; - distinguish facts, policy, editorial guidance and softer contextual signals; - apply hard eligibility and access rules in deterministic code rather than asking the LLM to remember exclusions; - avoid supplying irrelevant information merely because it is available; - preserve access to richer source material when the editorial process explicitly needs to inspect it.

This does not mean reducing every media item to identical fields or lengths. Some decisions genuinely require more context than others. The important point is that information volume should be intentional rather than an accidental source of weighting.

This principle also has practical benefits. Smaller, balanced contexts reduce inference cost and latency while making it easier to understand why the editorial model preferred one candidate over another.

And it should only be given the information it needs to think about it.

Several principles currently guide the project:

The station may surprise. The remote control must not.

Client controls should remain semantically predictable even when programme choices are not.

Never black; always still recognizably the same broadcaster.

When something fails, fallback should move upward through the editorial identity stack rather than immediately collapsing into a generic technical state.

Scheduling says when. Show Briefs say approximately what. The Station Program Committee decides what actually airs.

The schedule should describe television, not manually enumerate every file.

Content fit is more important than exact clock fit.

Fuzzy programme boundaries are preferable to awkward truncation or constant filler.

Explicit policy wins over AI classification.

AI can help identify sensitive material, but library exposure, child-lock and audience policy remain explicit operator decisions.

Viewing time is not a success metric.

ProbablyTV should not learn YouTube-style hook optimisation from passive viewing duration. Human context, mood and attention are too ambiguous for that.

The station should be thinking when there is something to think about.

Local intelligence should be event-driven rather than continuously burning compute simply because the station is on air.

Station memory requires lifecycle, not just storage.

Useful continuity may cross programme boundaries, but transient context must be able to decay and an operator must be able to retire a runaway topic.

Fresh context is editorial fuel, not a script.

Station Context should provide optional semantic material without requiring the editorial model to mention it.

Technical absence and editorial expectation are different facts.

For example, media with no audio track is not necessarily broken: a historical silent film may be intentionally silent. Playout should distinguish audio_present from an inference such as expected_silent.

The current reference client is tvOS, because it provides a practical quality target and is heavily used in the environment where ProbablyTV originated.

That does not define the full architecture.

Station intelligence, scheduling, programme state, Show Briefs and Station Program Committee logic belong on the server. Clients should implement the viewing experience and advertise their playback capabilities.

The longer-term goal includes inexpensive commodity streaming devices so that using ProbablyTV in another room does not require premium hardware at every television.

ProbablyTV is currently an experimental greenfield project.

The domain model and architectural boundaries are being worked out before implementation is allowed to harden assumptions that later become expensive to remove.

Some ideas are informed by direct experience with Subwave Radio, but television introduces different constraints and those results should not be copied blindly.

In particular, the project is currently interested in:

• catalogue identity that survives file moves, renames and replacement by better copies;
• semantic media understanding beyond conventional media-center metadata;
• conceptual programme blocks and fuzzy scheduling;
• Station Soul, Channel Identity, Show Briefs and edition-specific Programme Plans;
• dynamic EPG descriptions derived from the same Programme Plan that drives editorial selection;
• Station Context with explicit injection, decay, boundary and forget semantics;
• progressive, cacheable and cost-aware media analysis;
• local and event-driven editorial AI;
• explicit library and audience policy;
• personal/home video as legitimate linear-programming material;
• commercials, shorts, trailers and other interstitial material as editorial tools;
• reliable recovery when a channel or media item fails, including a semantic per-channel reset that rebuilds a valid broadcast rather than preserving broken execution state;
• distinguishing intentionally silent media from technically missing/broken audio;
• clients that behave predictably even when the station does not.

The project intentionally does not begin by asking users to manually construct every virtual channel.

Or, put another way:

Tunarr asks: "What do you want to put on your channel?" ProbablyTV tries to make sure you barely have to answer that question.

ProbablyTV's core architecture is about programming a catalogue, not about where every playable item physically originates.

In a much later version, an adapter could theoretically expose entitled content from an external streaming service to the Catalogue and Station Program Committee alongside local media. That could make the same editorial machinery useful across both.

This is deliberately not a v1/v2 goal, and it may never be practical. Authentication, DRM, subscription terms, licensing, regional availability, unstable APIs and provider changes all make this a hostile integration surface.

The architectural principle is therefore modest:

External streaming providers are an optional adapter horizon, not part of the foundation.

ProbablyTV must remain useful without them.

The docs/ directory will contain design notes, experiments and field observations as the project develops.

Recommended starting points:

• Small-LLM / living-radio field report: docs/WitWisdom_Small_LLM_Living_Radio.md
• Project vision: the evolving ProbablyTV vision/design document

ProbablyTV is deliberately being designed around uncertainty in the editorial layer, not uncertainty in the underlying system.

The programme committee may surprise you.

The catalogue should know what a file is.

The continuity presenter may make an absurd remark about the engineering department.

The scheduler should still know what programme is on.

A station can have character without surrendering operational truth.

That distinction is likely to remain one of the project's most important architectural boundaries.