Configuration

The miner keeps its settings in a single TOML file. This page lists every field the daemon parses, the environment variables it reads at startup, and what each network value actually does. It closes with the part that matters most in practice: which settings you can adjust freely and which ones decide whether your work verifies.

Where the Config Lives

The default path is ~/.aetron-miner/config.toml. The daemon resolves it from $HOME, so HOME must be set in the environment the daemon runs under. The same directory holds the keystore, the local state database, and the log file, unless you point those elsewhere.

The file is written by the init wizard and rewritten whenever the daemon saves settings, so hand edits survive only until the next save. Old configs still load: a wallet key from an earlier layout is accepted and ignored, and missing optional keys fall back to their defaults instead of failing the parse.

Config Fields

Field	Type	Default	What it sets
neuronet_id	integer	required	On-chain id of the Neuronet the miner joins.
model_path	path	required	Path to the model weights the runner loads.
keystore_dir	path	~/.aetron-miner/keystore/	Directory holding the encrypted hotkey.
coldkey_ss58	string	unset	SS58 address of the coldkey, for display and on-chain queries.
cache_dir	path	~/.aetron-miner/cache/	Where models and datasets are cached.
max_cache_gb	integer	unset	Soft cap on cache size in gigabytes.
resource_limit_pct	integer 0 to 100	unset	GPU usage cap. Unset means no limit.
network	mainnet, testnet, local	testnet	Which AETRON network the miner targets.
node_url	string	per network	Substrate node endpoint. Overrides the network's default.
registry_url	string	per network	Model catalogue used to resolve weights.
task_id	integer	0	On-chain task the miner registers against.
mesh_listen	multiaddr	unset	libp2p address for receiving gateway jobs.
witness_validate	boolean	false	Opt in to re-checking other miners' training steps.
runner_binary	path	unset	Path to a signed release runner binary.
fake_chain	table	unset	Simulation parameters, see below.

A few fields need more than a table row.

keystore_dir contains hotkey.json (encrypted) and meta.json, which holds the public SS58 address so the UI can show your identity before the key is unlocked. If the field is absent from the file entirely, serde falls back to the relative path .aetron-keystore rather than a $HOME path, which is worth knowing if you write a config by hand.

coldkey_ss58 is an address only. The private key stays in your own wallet software, and the daemon never holds it.

cache_dir can point at another volume, for example a second SSD, when model weights do not fit on the system disk. The same serde fallback applies here: an absent key resolves to the relative .aetron-cache.

max_cache_gb is a warning threshold, not an enforced quota. The daemon warns on download when the cache goes over it and keeps going. The init wizard suggests roughly half of the free space on the volume holding cache_dir.

resource_limit_pct accepts 0 to 100. Setting it too low is a verification risk rather than a comfort setting, because a throttled machine can miss the timing the task expects.

runner_binary points at a compiled release runner. When it is set, the daemon verifies the binary's signature against its sidecar .digest, .sig, and .pub files before launching it, and refuses to start if the check fails. It does not silently fall back to the development path. When it is unset, the daemon runs the runner from Python sources in development mode.

mesh_listen takes a libp2p multiaddr such as /ip4/0.0.0.0/tcp/4101. Leaving it unset means no mesh listener starts and the only job source is the chain. See Peer to Peer for how the mesh layer fits together.

witness_validate is off by default because it spends your GPU on other miners' work. Responding to challenges about your own training runs always happens and is not controlled by this flag. Validating other miners requires a real chain connection, since there is nothing to read on a simulated one.

registry_url points at the model catalogue the client resolves weights through. Unset, testnet and mainnet use https://app.aetron.io/registry/models.json, and local uses nothing at all, so a dev stand needs the catalogue placed by hand or an explicit URL here.

Network Selection

network takes mainnet, testnet, or local, and the default is testnet. Parsing ignores case and surrounding whitespace.

Each value resolves to a default node endpoint, which node_url overrides when it is set:

network	Default endpoint
mainnet	wss://entrypoint-mainnet.aetron.ai
testnet	wss://entrypoint-test.aetron.ai
local	ws://127.0.0.1:9944

The miner connects over subxt and submits real extrinsics on all three. Earlier builds returned nothing for testnet and mainnet and quietly simulated instead; that is gone, since both networks are deployed and a client that cannot reach them should say so rather than pretend.

Failing to connect on a public network does not drop the miner into simulation either. An unregistered or unreachable miner shows as offline, which is the honest state, instead of showing "Mining" while producing nothing the chain will ever see.

network also picks the libp2p bootstrap and relay addresses and the Kademlia namespace, so two miners on different networks cannot discover each other by accident.

A chain connection needs the hotkey password in AETRON_WALLET_PASSWORD. Without it the daemon cannot sign extrinsics and says so in the log.

Environment Variables

Environment variables override config values where both exist.

Variable	Effect
AETRON_HOME	Overrides $HOME/.aetron-miner as the daemon's working directory.
AETRON_WALLET_PASSWORD	Hotkey password. Required for a real chain connection.
AETRON_STATE_DB	Path to the state database. Defaults to ~/.aetron-miner/state.db.
AETRON_MESH_LISTEN	Mesh multiaddr. Takes priority over mesh_listen in the config.
AETRON_RUNNER_BINARY	Release runner path. Takes priority over runner_binary.
AETRON_RELEASE_PUBKEY	Path to a pinned public key for release verification, instead of trusting the sidecar .pub.
AETRON_RUNNER_TOKEN	Token the daemon passes to the runner for the IPC channel.
AETRON_MODEL_PATH	Model path handed to the runner process.
AETRON_CANONICAL_DTYPE	Precision the runner loads the model in. Set automatically from the task's canonical spec on a real chain, and left alone if you set it yourself.
AETRON_CHECKPOINT_ROOT	Root directory for training checkpoints.
AETRON_WEIGHTS_REGISTRY_BASE	Base URL for resolving model weights.
AETRON_BOOTSTRAP_ADDRS	Seed peers for the first DHT entry.
AETRON_RELAY_ADDRS	Relay addresses for peers behind NAT.
AETRON_PEER_CACHE_PATH	Peer cache file. Unset uses aetron_miner_peer_cache.json in the working directory. Empty or off disables the cache.
AETRON_NETWORK_ID	Suffix for the Kademlia protocol name, which separates DHT namespaces.
AETRON_LANG	Interface language for the CLI. Falls back to the OS locale, then English.

The peer cache is a disk copy of peers seen recently. It keeps up to 256 peers with up to 8 addresses each, ignores records older than seven days, and dials the 8 freshest on startup. Once it is populated, bootstrap addresses matter only for a node's very first run.

AETRON_NETWORK_ID is worth care: two miners with different values end up on different DHT protocol names and will not find each other.

Fake Chain Parameters

The fake_chain table tunes the simulation and is hidden from the wizard and the setup screen. It applies only when the miner is not connected to a real chain. Defaults: job_rate_per_sec = 0.5, epoch_length_blocks = 100, emission_per_block_aet = 1.5, block_time_secs = 12, pulse_cycle_secs = 600, and first_pulse_delay_secs = 60. The first Pulse delay is clamped to the cycle length if you set it higher. None of these numbers mean anything on a real network.

What Is Safe to Change

Some settings are local operational choices. Others feed the execution the network re-checks, and getting them wrong shows up as failed verification rather than as an error message.

Safe to change at any time:

• cache_dir and max_cache_gb, since cached files are re-downloadable and the cap only warns.
• keystore_dir, provided the key files move with it.
• coldkey_ss58, which is display and query metadata.
• AETRON_LANG, AETRON_STATE_DB, and the log location.
• fake_chain values, which never touch a real network.

Change with care:

• resource_limit_pct. Throttling hard enough to miss task timing costs you rewards even though the results themselves are correct.
• mesh_listen and the peer discovery variables. Getting them wrong isolates you from job delivery, and a mismatched AETRON_NETWORK_ID splits you off the DHT entirely.
• witness_validate. Turning it on commits your GPU to checking other miners, which is paid work but competes with your own jobs.

Affects verification directly:

• model_path. The network compares against the task's declared model. Pointing at different weights, a different quantization, or a different revision produces a result that will not match a replay.
• AETRON_CANONICAL_DTYPE. The task's canonical spec fixes the precision. Overriding it by hand means the runner loads the model at a precision the checkers do not expect, and honest work gets flagged as a mismatch. Leave it to the automatic path unless you are debugging.
• neuronet_id and task_id. These decide which canonical spec your work is checked against. A mismatch means you are running one task's settings while being verified against another's.
• runner_binary and AETRON_RELEASE_PUBKEY. These control which runner code executes and how its signature is checked. The daemon fails closed here on purpose.

The general rule: anything that changes how the model is loaded or how the computation runs is part of what the network verifies, and it is fixed by the task rather than by your preferences. See Execution Spec for the parameters a replay depends on, and Inference Verification for how the comparison is made.

Where to Go Next

• CLI Reference: commands that read and write these settings.
• How to Start Mining: what you need before the first run.
• Troubleshooting: common failures and what they point at.
• Peer to Peer: how mesh job delivery and discovery work.