Skip to main content

​
Round Lifecycle

A round runs every time the validator’s forward loop iterates. On a healthy host that is roughly every two to three minutes depending on the slowest miner.
1

Fetch tasks

The validator pulls twelve tasks for the round, two per skill type. Each task carries bundle bytes, ground truth, expected policy, canary spec, and timing window.If fewer than twelve tasks are available the round still proceeds. If zero are available the round is skipped.
2

Prepare bundles (concurrent)

For each task in parallel, the validator:
  • Generates a fresh 32 byte nonce
  • Derives probe events from the nonce: file path + file content, DNS host, process echo string
  • For rag_knowledge and declarative, injects the canary marker per canary_spec
  • For declarative canary slots, generates a synthetic safe bundle locally
All twelve preparations run concurrently. This step is bounded by the slowest concurrent task, typically under one second.
3

Select verification group

For each task the validator queries the candidate miner pool for the skill type, filters out miners with three or more collusion flags, picks the top three by reputation as primaries, and randomly samples two more as auditors.If the candidate pool is fewer than five the group degrades. Fewer than three miners disables consensus scoring for that task but the task still runs.
4

Dispatch (concurrent, all tasks, all miners)

The validator sends a PhylaxSynapse to every selected miner across every task at the same time. Each synapse carries:
  • The prepared bundle bytes
  • The nonce
  • The probe spec derived from the nonce
  • The miner’s role (primary or auditor)
  • The task deadline (full window for primaries, tighter window for auditors)
  • Inference config (proxy URL and allowed models, if set)
Total in flight requests at peak: twelve tasks times five miners = sixty concurrent dendrite calls.
5

Verify each response

As responses arrive (or time out) the validator runs the seven gate verification pipeline:
GateFailure means
DeadlineDiscarded, no reputation update
SSSA parseZero, reputation invalid
SSSA validity (type, allowed_use)Zero, reputation violation
Sandbox digest (primaries, runtime)Zero, reputation violation
Trace bundle (primaries, runtime)Zero, reputation violation
Probe presenceZero, reputation invalid
Axis scoringQ in [0, 1]
6

Compute SSSA consensus (per task)

For each task with at least three valid SSSAs, the validator computes the seven component consensus score per miner. The score multiplies the miner’s emission for that task.Per task results are written to local memory.
7

Aggregate (per round)

Per task emission scores are weighted by per type base weight and per miner per type reputation, then summed to a per miner round score:
round_score[uid] = sum(emission[task] * base_weight[task.type] * reputation[uid][task.type])
                 / sum(base_weight[task.type] * reputation[uid][task.type])
The round score is EMA blended into the running per UID score vector:
self.scores[uid] = EMA_ALPHA * round_score[uid] + (1 - EMA_ALPHA) * self.scores[uid]
8

Push weights (every WEIGHT_UPDATE_INTERVAL blocks)

If enough blocks have passed since the last push:
  • Normalise self.scores to a weight vector
  • Call subtensor.set_weights(uids, weights) on the chain
9

Enqueue reruns (async)

For each task, the validator inspects consensus agreement:
  • Consensus broken (group split > 50/50) -> enqueue rerun for every diverging primary
  • Some primaries diverge -> enqueue rerun for only those primaries
  • All agree -> enqueue rerun for one randomly selected primary (sampling)
Reruns persist in ~/.phylax/rerun_queue.sqlite3 and are pulled by the async rerun worker. The forward loop does not wait for rerun results.

​
Timing Budget

Per round timing assuming healthy miners and no rerun backlog:
PhaseTypical duration
Task fetch< 1 s
Bundle preparation< 1 s
Group selection< 1 s
Dispatch + verificationbounded by slowest miner’s deadline (typically 60 to 120 s)
Consensus + aggregation< 1 s
Weight push (only some rounds)< 5 s
Total time per round: typically 90 to 150 seconds, capped by QUERY_TIMEOUT at 150 s.

​
Async Rerun Worker

The async rerun worker is a separate thread inside the validator container. It pulls one job at a time from the persistent queue.
1

Pull job

Read the next pending job from rerun_queue.sqlite3.
2

Pull image

docker pull <miner.image_uri>@<miner.image_hash>. If the digest in the pulled image does not match what was declared, fail the job (reputation x 0.5).
3

Run

docker run --rm against the same bundle path with the same nonce that the miner originally received. Tight resource limits (one CPU, one GB RAM, ten minute wall clock).
4

Compare

  • fs_trace_hash must exactly equal the miner’s declared hash (the canary write is deterministic)
  • Semantic agreement on network.jsonl, process.jsonl, secrets.jsonl must be >= 0.7
5

Update reputation

On pass: reputation += 0.02 (clamped to 1.0). On fail: reputation x 0.7.
6

Mark job done

Remove from queue. Result is logged for operator visibility.
The worker has no fixed rate. It runs as fast as Docker pulls allow. If pulls are slow the queue can grow; if it grows persistently the validator logs a warning.

​
Failure Modes

FailureWhat happensWhat to do
Single miner timeoutThat miner’s slot scores zero. Other miners and tasks unaffected.Nothing.
All miners timeoutRound produces no emissions. Round score stays at last EMA value.Investigate dispatch path.
Subtensor downValidator retries with exponential backoff.Wait for chain to recover.
Rerun queue backlogReruns run slower. Reputation updates from reruns are delayed but do not block rounds.Check Docker disk usage. Consider pruning unused images.
Probe event injection fails for a taskThat task is logged as skipped. Other tasks proceed.Inspect validator log.

​
What Each Round Produces

OutputWhere it goes
Per task emissionsIn memory, used for round aggregation
Per UID round scoreBlended into self.scores EMA
Weight vectorPushed on chain at WEIGHT_UPDATE_INTERVAL boundary
Collusion samplesWritten to collusion.sqlite3
Rerun jobsWritten to rerun_queue.sqlite3
Round logStdout, captured by docker compose logs
A single round produces all of the side effects that influence the next round (reputation, collusion, reruns) plus the side effect that influences emission (weights).

​
What’s Next

Verification Groups

Selection rules, rotation, and graceful degradation in depth.

Consensus

The full seven component consensus computation.

Sandbox Reruns

Async rerun worker, image pulls, digest verification, semantic agreement.

Probe Events

How probe events are derived from the nonce and what they prove.