Aether Mind v6.0 — QuantumAI Blockchain Native Generator
A 558M-parameter distilled student of Qwen/Qwen2.5-0.5B-Instruct,
trained from scratch in pure Rust (candle 0.10) with the
10-Sephirot + 2-generalist + 2-sink attention head split that is
the core architectural claim of the QuantumAI Blockchain's Aether Mind
on-chain neural cognitive engine.
This is the second public Aether release and the first that is
native to the on-chain inference path — V6.0 is the model the
aether-mind
binary loads, not a LoRA adapter on top of a 7B base.
The previous release, aether-v5.2-lora,
is a 7B PEFT adapter intended for batch off-chain reasoning. V6.0 is
the smaller native generator that fits in the on-chain Aether
Mind's ~2.4 GB RAM envelope and runs at ~500 tokens/sec on a
consumer RTX 3080 Ti.
What you're getting
Field
Value
Base model
Qwen/Qwen2.5-0.5B-Instruct (initialised from, then distilled)
The model converged hard in the first ~10K steps, then plateaued at
the representational floor for its current context window (64
tokens). The plateau is structural, not optimisation — see "Honest
caveats" below.
Architecture — what makes V6 different
V6 is not a vanilla Qwen2.5 fine-tune. The attention layer
implements a 14-head split designed for on-chain cognitive routing:
10 Sephirot heads — one per cognitive domain in the Aether
Mind's specialisation map (Keter → Malkuth). Each head's attention
pattern is what the on-chain pallet_qbc_aether_anchor records as
the per-cycle attestation root.
2 generalist heads — un-gated, full-context attention. Used for
the "global workspace" path in aether-mind.
2 sink heads — anchor-token attention (first 4 tokens of the
sequence) for stable long-context performance, following the
standard "attention sink" finding.
The Sephirot eviction order is configured in config.json for the
KV-cache management path that aether-mind uses to keep the
hot-set bounded in 12 GB VRAM under live inference.
How to use
Native runtime (recommended) — Rust aether-mind
The model is designed to be loaded by the on-chain Aether Mind
binary in the QuantumAI-Blockchain/qubitcoin-aether
repo. Set AETHER_V6_CHECKPOINT to the local path of
model.safetensors and start the systemd unit; the binary loads the
weights via candle into the V6 transformer crate.
There is no canonical 🤗 transformers loader for the V6
architecture — the 14-head split + Sephirot routing are not in the
upstream Qwen2Model. We publish the weights for transparency and
reproducibility; production use goes through the Rust binary above.
Evaluation
Not yet run. The Phase-1 training run completed
2026-05-20 00:52 AEST; lm-evaluation-harness against MMLU /
ARC / HellaSwag / TruthfulQA is the next session's work. We will
back-fill the numbers + the comparison vs v5.2-lora here when
they land. Estimated runtime: ~30 min on the same 3080 Ti.
Until then, treat this release as an architecture + weights
attestation: it proves the V6 stack trains end-to-end and converges
to a real loss curve, which is the prerequisite for the long-context
curriculum (16K → 64K → 128K → 1M) that v6.1+ will ship.
Intended uses
On-chain Aether Mind native inference. The V6 binary loads
these weights directly. The 10-Sephirot attention pattern is what
the chain's pallet_qbc_aether_anchor
records as the per-block consciousness state.
Architecture reference. Reproducible training of a Sephirot-
routed transformer with native sparse attention. The
aether-transformer
crate is the canonical implementation.
Distillation substrate. Future fine-tunes from this checkpoint
using the QuantumAI Blockchain curated corpus.
Out-of-scope uses
General-purpose chat or instruction-following without fine-tuning.
V6.0 is a Phase-1 distillation, not an instruction model. Even after
30K steps it has not seen instruction-format data at length; its KL
target is the base Qwen2.5-0.5B-Instruct's next-token distribution,
not chat-format outputs.
Long-context inference. The training ran at 64-token
context. See "Honest caveats". Generations beyond ~128 tokens
will degrade.
Production deployment without your own evals. No lm-eval-harness
numbers yet.
Safety-critical decisions. No red-team eval.
Honest caveats — what didn't happen
Trained at 64-token context, not 4K
Phase-1 was configured for 4096-token context, but a numerical
instability was discovered in the V6 attention forward pass at
sequence lengths > ~100 tokens (BF16 precision loss in the Q@K^T
matmul accumulating across longer sequences). The bug reproduces
deterministically; four mitigations were tried (F32 KL math, corpus
filter, no-distill, low-LR), all hit NaN at the same sequence-
length threshold. The workaround used for v6.0 was --context 64,
which truncates rows so the bug never triggers.
This is a known limitation, tracked in
docs/ops/v6-training-nan-bug.md
in the source repo. The fix lives in aether-transformer/src/v6/attention.rs
— add F32 casts in the Q@K^T matmul + softmax path across all four
attention variants (Sephirot / generalist / sink / summary). When
that lands, v6.1 will re-train at the full 4K→1M context
curriculum and supersede this release.
Loss plateau is real
The avg-loss plateau from step 10K → 30K (7.68 → 8.39, slight
regression) is the model hitting its representational ceiling at
64-token context. Longer contexts will let the next release recover
and improve.
No instruction-format fine-tune
The training data is the Aether curated corpus packed at 4K-token
context (rows truncated to 64). We did not insert chat-format
instructions, system prompts, or RLHF preferences. Treat this as a
raw foundation checkpoint.
Distillation against base, not chat
The teacher is Qwen/Qwen2.5-0.5B-Instruct's base forward — not its
chat-formatted forward. The distillation transfers token-level next-
prediction behaviour; chat-template alignment is a separate
training step that hasn't been run.
The dataset is not currently public — it is a curated mixture from
many sources and has not been release-cleared at the per-source
level. The model is the only public artifact in this line for now.
Carbon emissions
Single consumer GPU (RTX 3080 Ti, ~300 W TDP) × 49.6 min wall-clock
≈ 0.25 kWh, < 1 kg CO₂e on a grid mix. Comparable to a short web
streaming session.
Connection to the QuantumAI Blockchain
The Aether Mind is a Rust neural cognitive engine that runs on the
QuantumAI Blockchain — every block records attention-derived
consciousness metrics (HMS-Phi) and Proof-of-Thought hashes on-chain
via the pallet_qbc_aether_anchor pallet. The same chain hosts an
8-qubit VQE mining consensus (Proof-of-SUSY-Alignment), a
QVM-compatible smart contract layer with 10 quantum opcodes, and
post-quantum signatures (CRYSTALS-Dilithium5 + ML-KEM-768 P2P).
V6.0 is the native generator for that engine. v5.2-lora is the
larger (7B) off-chain reasoning model. The two ship side by side
because they have different roles: V6 lives in the on-chain
inference path (low latency, small footprint, Sephirot-aware
attention); v5.2-lora batches off-chain reasoning workloads.
License + citation
Apache-2.0 (matches the base model license).
bibtex
1@misc{aether_mind_v6_2026,
2 title = {Aether Mind v6.0 --- QuantumAI Blockchain Native Generator},
3 author = {{BlockArtica} and {QuantumAI-Blockchain}},
4 year = {2026},
5 url = {https://huggingface.co/QuantumAI-Blockchain/aether-mind-v6.0},
6}
