Subnet 108: TalkHead
TalkHead is Bittensor Subnet 108, a subnet for talking-head generation: producing a photorealistic animated face that speaks in sync with given input. The TalkHead subnet README source describes a competition where miners submit Dockerized talking-head models and validators evaluate them through a secure GPU executor before setting weights.
What TalkHead Rewards
Rather than submitting finished videos, miners submit their actual models, packaged as containers so the network can run them itself. The subnet README says miners submit Docker image digests, the executor evaluates submitted images, and validators consume the resulting scores. That makes the model container the competitive artifact, not a self-reported sample video.
The subnet rewards models that generate the best talking-head output on shared challenge inputs, judged on both output quality and efficiency. Because every miner’s model is run through the evaluation path, the comparison is standardized around executor output instead of around miner claims.
Executor Context
The TalkHead executor README describes the executor service as maintaining miner submissions, evaluating miners continuously, and exposing scores. In article terms, the executor is the measurement layer between submitted model containers and validator weight setting.
This boundary is important for understanding the miner and validator split. Miners provide the runtime image they want evaluated. Validators coordinate submissions and scoring intake, but the executor performs the model run, captures the outputs, and records scoring metrics that validators can use.
Scoring Context
TalkHead’s main README describes a winner-take-all policy: the highest score wins, the winning miner receives weight, and all other miners receive zero for that evaluation. The executor README narrows the score itself by describing quality-first scoring with an efficiency modifier and by stating that winner selection prefers the maximum final score.
For readers, that means TalkHead does not reward model submission volume by itself. A miner needs a container that can survive the shared evaluation path, produce acceptable talking-head output, and do so efficiently enough to beat the other eligible submissions.
Executor Evidence Boundary
The TalkHead subnet README describes miners submitting model image digests rather than finished videos. That detail changes how evidence should be read: the competitive object is a runnable model container that can be evaluated again, not a demonstration clip selected by the miner.
The TalkHead executor README describes the executor as maintaining miner submissions, evaluating miners continuously, and exposing scores. This places the executor between miner submissions and validator weight setting. Validators can use executor results, while miners still have to provide containers that work inside the shared scoring path.
The executor source also frames scoring as quality-first with an efficiency modifier. That means a fast model is not enough by itself if the generated talking-head output fails the quality checks, and a high-quality model can still be compared on resource use or latency once quality is acceptable. The reward signal is therefore a combined evaluation of output quality and practical execution cost.
This boundary also explains the importance of standardized challenges. If every miner’s container is run through the same executor process and challenge set, the comparison is less about marketing claims and more about observed behavior under shared conditions. A miner submission is strongest when the executor can run it, measure it, and compare it with other eligible submissions in the same round context.
For readers, TalkHead is best understood as an evaluated model-submission subnet. The miner supplies the model runtime, the executor produces comparable evidence, and validators use that evidence when setting weights. A manually selected sample video or off-path benchmark is therefore not the same kind of evidence as an executor-scored subnet submission.
References: TalkHead subnet README source, TalkHead executor README source
Miner and Validator Roles
Miners are the model builders. A miner trains a talking-head model, publishes it as a container image, and submits a reference to that image to the subnet so it can be evaluated. The miner does not run the evaluation itself; it only supplies the model.
Validators coordinate the evaluation and translate its results into rewards. They collect the miners’ submissions and hand them to an executor service that runs each model in a sandboxed GPU environment, feeds it the same standardized challenge inputs, captures the outputs, and measures how well and how fast each model performs. At the article level the split is straightforward: miners supply talking-head models, while validators use executor scores to weight the network.
Source and Live Data
Live SN108 subnet data is available on TaoStats. The mechanism details in this article are tied to the TalkHead subnet README and executor README rather than to live identity fields.
Relationship to Yuma Consensus
Subnet 108 uses Yuma Consensus to convert the talking-head model evaluation weight vectors that validators submit into the emission shares distributed to miners and validators within the subnet each tempo. The linked documentation describes how validator weight submissions are aggregated into consensus weights for each miner registered on the subnet.
In TalkHead’s context, validators coordinate model-container submissions and hand them to an executor service that runs each model in a sandboxed GPU environment, feeds it standardized challenge inputs, captures outputs, and measures quality and efficiency, then use those executor scores to translate performance into weight vectors for the subnet. The Emission documentation describes how those consensus weights determine each participant’s share of the subnet’s accumulated emission each tempo.
Development Stage Context
The Introduction to Bittensor describes subnet development as moving from localnet to testnet and then mainnet. For TalkHead (SN108), that sequence changes how readers should interpret talking-head model competition examples and executor-based scoring outcomes.
In localnet, TalkHead-compatible miners and validators can be developed and tested in an isolated environment. Localnet model evaluation results and emission outcomes do not represent production subnet performance.
On testnet, TalkHead-compatible model submission workflows can be exercised in a shared, non-production network. Testnet executor scores and validator weights are separate from mainnet subnet state.
On mainnet, TalkHead (SN108) is the live production subnet where miners submit talking-head model containers and validators score them through a shared executor environment to determine real Bittensor emissions. The TalkHead repository describes the mechanism that applies on the production network.
The Bittensor Networks reference separates mainnet, testnet, and localnet. A model evaluation result or emission outcome from one environment should not be read as representing production subnet performance in another environment.
Reader Boundary
Subnet 108 TalkHead should not be read as a generic video-hosting subnet or as proof that a hand-picked talking-head demo clip earns weight. The TalkHead subnet README describes miners submitting Docker image digests that validators route through a shared evaluation path rather than finished videos chosen by the miner.
Runnable Containers Are the Competitive Artifact
The same README places the competitive object on runnable model containers the executor can evaluate repeatedly under standardized challenges. A sample video or off-path benchmark does not substitute for an executor-scored container submission on this subnet.
Winner-Take-All Weights Follow Executor Scores
The subnet README describes a winner-take-all policy where the highest score receives weight and other miners receive zero for that evaluation. The TalkHead executor README frames scoring as quality-first with an efficiency modifier, so validators weight observed executor output rather than unaudited miner claims.
Validator weights still flow through Yuma Consensus to determine emissions each tempo (Yuma Consensus, Emission).