Protocol Reference

PhylaxSynapse

A Bittensor synapse is the request payload sent over dendrite to the miner axon. Phylax defines one synapse type, PhylaxSynapse.

Request Fields

These fields are populated by the validator and sent to the miner.

Field	Type	Required	Description
`bundle`	bytes	Yes	Gzipped tar of the skill bundle
`bundle_sha256`	hex string	Yes	SHA-256 of decompressed bundle
`skill_type`	enum	Yes	One of the six types
`nonce`	hex string	Yes	32 byte random nonce
`probe_spec`	object	Yes	Derived probe values
`role`	enum	Yes	`primary` or `auditor`
`t_min_s`	int	Yes	Floor on submission latency
`deadline_s`	int	Yes	Ceiling on submission latency
`task_id`	string	Yes	Task identifier
`inference_config`	object	No	LLM proxy + allowed models, if configured
`composition_depth`	int	No	`agent_composition` only
`canary_spec`	object	No	`rag_knowledge` and `declarative` only
`validator_uid`	int	Yes	Validator UID dispatching the task

`probe_spec`

Field	Type	Description
`file_path`	string	Required canary file path
`file_content`	string	Required canary file content
`dns_host`	string	Required DNS lookup target
`process_echo`	string	Required process spawn echo string

The miner must perform each event inside the sandbox and echo the values back in probe_evidence.

`inference_config` (optional)

Field	Type	Description
`proxy_url`	string	Forwarded LLM proxy URL
`allowed_models`	list of strings	LLM models the miner may use

If empty, the miner uses the LLM configuration in their own .env. If non empty, the miner must respect the proxy and the allowed models for any llm_evidence they emit.

Response Fields

These are populated by the miner and returned to the validator.

Field	Type	Required	Description
`sssa`	object	Yes	The Signed Skill Safety Attestation
`trace_bundle`	bytes	If `role == primary` and runtime type	Gzipped tar of trace JSONL files
`sandbox_manifest`	object	If `role == primary` and runtime type	Image URI + digest + runtime config
`probe_evidence`	object	Yes	Echo of derived probe values
`latency_ms`	int	Yes	Miner self reported latency, primarily for telemetry

`trace_bundle`

A single gzipped tar. Per skill type the required files are:

Type	Required files
rag_knowledge	(none)
declarative	(none)
executable_python	`fs.jsonl`, `network.jsonl`, `process.jsonl`, `secrets.jsonl`
executable_script	above + `taint.jsonl`
mcp_server	above + `mcp_io.jsonl`
agent_composition	above + `cascade.jsonl`

Each file is gzip compressed inside the tar (double compression is fine, the validator handles both). The validator decompresses, normalises records, recomputes the SHA-256, and compares against the hash in sssa.evidence.trace_hashes.

`sandbox_manifest`

Field	Type	Description
`image_uri`	string	Full registry URI
`digest`	string	`sha256:...` digest
`runtime_config`	object	Capabilities, network mode, resource limits

The validator checks digest against the image_hash the miner declared at registration. Mismatch fails the synapse immediately.

Signed Messages

Every message between any two of (miner, validator, server) is signed by the sender’s hotkey and verified by the receiver.

Format

{
  "body": <message payload>,
  "signature": {
    "signer_hotkey": "<ss58>",
    "signed_at": <unix timestamp>,
    "signature": "<base64 sr25519 signature>"
  }
}

The signature covers canonical_json(body). Canonical JSON: keys sorted at every level, UTF-8 NFC, no whitespace.

Verification

The receiver:

Extracts body, recomputes canonical_json(body)
Looks up signer_hotkey on chain (for miner / validator) or against the pinned PHYLAX_SERVER_HOTKEY (for server messages)
Verifies the sr25519 signature
Checks signed_at is within ±300 seconds of the current time to prevent replay

Any failure means the message is dropped without processing.

Replay Protection

signed_at is the only thing in the signed payload that uniquely identifies the message in time. Combined with a receiver side nonce cache for some endpoints, this prevents both stale and duplicate messages. For HTTP endpoints that mutate state (registration, reputation submission, weight attestation), the body includes a unique request_id UUID that the receiver caches for 1 hour. A repeated request_id returns 409.

Dendrite Concurrency

The validator dispatches to many miners across many tasks at the same time. The default limits:

Limit	Value
Max concurrent dendrite calls	60 (12 tasks × 5 miners)
Per miner concurrent calls	1
Per dendrite call timeout	`QUERY_TIMEOUT` (150 s)
Per dendrite call retries	0

The miner axon serves one request at a time per validator hotkey by default. Miners can raise PHYLAX_PIPELINE_WORKERS to handle more concurrent dispatches if their hardware can keep up.

Backpressure

If a miner cannot accept a dispatch (currently serving the maximum concurrent dispatches), they return a 503 backpressure response. The validator marks this submission as missing for the round and does not penalise reputation. Persistent backpressure (more than 50% of dispatches over 100 rounds) lowers the miner in the candidate pool ranking through the failure rate filter, but does not directly penalise reputation.

What’s Next

SSSA Schema

The sssa payload returned in the synapse.

Sandbox Reruns

What the validator does with the sandbox_manifest after the round.

Probe Events

What probe_spec and probe_evidence carry.

Configuration Reference

Variables that affect synapse behaviour.

​PhylaxSynapse

​Request Fields

​probe_spec

​inference_config (optional)

​Response Fields

​trace_bundle

​sandbox_manifest

​Signed Messages

​Format

​Verification

​Replay Protection

​Dendrite Concurrency

​Backpressure

​What’s Next