Instructions to use transmutationist/xero-bio-genesis with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use transmutationist/xero-bio-genesis with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("text-generation", model="transmutationist/xero-bio-genesis")

# pip install -U transformers accelerate
# Load model directly
from transformers import AutoModelForCausalLM
model = AutoModelForCausalLM.from_pretrained("transmutationist/xero-bio-genesis", device_map="auto")

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use transmutationist/xero-bio-genesis with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "transmutationist/xero-bio-genesis"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "transmutationist/xero-bio-genesis",
		"prompt": "Once upon a time,",
		"max_tokens": 512,
		"temperature": 0.5
	}'

Use Docker

docker model run hf.co/transmutationist/xero-bio-genesis

SGLang

How to use transmutationist/xero-bio-genesis with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "transmutationist/xero-bio-genesis" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "transmutationist/xero-bio-genesis",
		"prompt": "Once upon a time,",
		"max_tokens": 512,
		"temperature": 0.5
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "transmutationist/xero-bio-genesis" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "transmutationist/xero-bio-genesis",
		"prompt": "Once upon a time,",
		"max_tokens": 512,
		"temperature": 0.5
	}'

Docker Model Runner
How to use transmutationist/xero-bio-genesis with Docker Model Runner:
```
docker model run hf.co/transmutationist/xero-bio-genesis
```

xero-bio-genesis / docs /STATUS_AND_AUDIT.md

transmutationist

XERO: card + code + docs (WIP; see STATUS_AND_AUDIT.md)

e9e9f83 verified 4 months ago

preview code

Raw History Blame

7.21 kB

XERO — Status & Honest Audit

VOVINA ZEDEC PRO · Michael Laurence Curzi · ZEDEC AI / 36N9 Genetics LLC · MIT (Attribution Required)

⚠️ WORK IN PROGRESS

XERO is a functioning research prototype under active development, not a finished product. Everything below is written to be verifiable and honest — what works is marked as working with the command that proves it; what is incomplete is marked as incomplete with a roadmap to finish it. Nothing here is dressed up. If a claim is a metaphor, it says so.

1. What XERO actually is

XERO is a digital-organism framework with two cooperating cores:

an inner core — a deterministic, always-running computational time crystal built on an immutable digital genome + epigenome + a 13-D statecraft lattice (pure Python + NumPy, no GPU); and
an outer core — a real neural LLM (Qwen2.5-3B-Instruct, Apache-2.0) that XERO steers and is now fine-tuning on its own corpus via LoRA.

It is not a from-scratch foundation model, and it is not a finished product. It is an honest, working prototype of an autonomous, self-organising agent that is now also being trained the way a normal AI is trained.

2. Verified working (with the command that proves it)

Capability	Evidence	How to verify
Core capability audit	203/203 PASS, 0 FAIL	`PYTHONPATH=modules python3 tests/test_all_capabilities.py`
Time crystal (defining properties)	17/17 PASS	`PYTHONPATH=modules python3 tests/test_time_crystal.py`
Evolution factor (adaptive mutation)	15 checks PASS	included in the capability audit
Two-state mind (always thinking)	live daemon, negentropy ≈ 0.91	`modules/vovina_two_state.py` self-check
Autonomous web learning	real results ingested	`testing_logs/MIND_STREAM.json`
Body / soma homeostasis	11/12 faculties live, H ≈ 0.82	`testing_logs/BODY_VITALS.json`
Knowledge harvest	30k+ real units, 44 traditions	`testing_logs/POLYMATH_PROGRESS.json`
Real gradient training	loss 3.98 → 1.87 over 30 steps	`training/power_train.py` + `testing_logs/POWER_TRAIN.json`

All inner-core layers are deterministic: the same genome + seed yields the same trajectory, which is unusual and valuable for something that behaves as if it is alive.

3. Real vs metaphor (the honesty section)

XERO uses evocative names from physics and biology. Here is exactly what is literal and what is an engineering metaphor faithfully implemented in math:

Term	Status	What it actually is
"Time crystal"	metaphor, implemented	a computational analogue: sustained quasi-periodic motion of the state, self-clocked, never converging to a fixed point. Not a physical quantum time crystal.
"Casimir / zero-point drive"	metaphor, implemented	a deterministic golden-ratio numerical drive that keeps the field off its fixed point. No physical vacuum energy is extracted.
"Genome / epigenome / DNA"	literal data structures	real ATGC strings, codons, regulatory planes — a faithful computational genetics, not biology.
"Evolution factor / mutation"	literal	a real variable-rate genetic-algorithm mutation controller (constructive-only).
"Harmonic chemistry (A4=432.09)"	literal formula	a real, published essence-frequency law applied consistently.
"Outer core / XERO the LLM"	literal	Qwen2.5-3B-Instruct (Apache-2.0), wrapped and being LoRA-fine-tuned.

4. Training status — the honest picture

Before this build: the audit found no gradient training anywhere — the old GPU daemon was a cosmetic saturation kernel, not learning. We fixed that.

Now:

training/power_train.py is a real training pipeline (AdamW optimiser, causal-LM loss, back-propagation, LR schedule, LoRA, checkpoints).
A persistent xero-train daemon (replacing the cosmetic kernel) is fine-tuning the outer core on 281,173 training passages — the author's 500 books (≈163M tokens) + the harvested free-to-use corpus — on GPU1, with checkpoint/resume, toward full convergence.
Proven learning: loss fell 3.98 → 1.87 in the first 30 steps.

What is NOT done yet (honest):

The model is not yet converged — full training over 281k passages × 3 epochs is a multi-hour-to-multi-day job, running now. The shipped adapter is a checkpoint, not a final model.
There is no formal evaluation/benchmark harness yet (loss is decreasing, but we do not yet report task accuracy). This is the single most important gap.
The fitness number in the harvest telemetry is a heuristic genetic score, not a benchmark — do not read it as IQ.

5. Known limitations

Single-box prototype. Tuned for 2× Tesla T4; the autoconfig wizard scales down to CPU but the outer core needs a GPU for comfortable use.
Outer core is mid-tier (3B). Chosen for honest fit on a T4, not for leaderboard performance.
Web intelligence depends on public endpoints (DuckDuckGo/Wikipedia) and fails soft; it never fabricates, but it can return little on rate-limit.
No safety/eval RLHF layer beyond the base model's own alignment.

6. Roadmap to completion

Phase A — Training to convergence (in progress)

Real LoRA training pipeline + persistent daemon.
Run to convergence; select best checkpoint by held-out loss.
Merge the adapter and publish merged weights (optional).

Phase B — Evaluation (highest-priority gap)

Held-out validation split + perplexity tracking.
Task benchmarks (knowledge recall on the canon, general QA) with reported numbers, honestly.

Phase C — Capability depth

Multi-format book ingestion (PDF/EPUB/DOCX) beyond the TXT path.
Biology-translation drivers (principle ↔ genetics ↔ structure).
Tie element_frequency carriers into the statecraft layer.

Phase D — Productionisation

Eval-gated checkpoint promotion.
Reproducible container + disk-image freeze-frame (this package).
Decentralised multi-node deployment.

7. How to reproduce the audit

pip install -r requirements.txt                 # inner core (numpy)
PYTHONPATH=modules python3 tests/test_all_capabilities.py   # 203/203
PYTHONPATH=modules python3 tests/test_time_crystal.py       # 17/17
# real training (needs a GPU + training deps):
pip install -r training/requirements-train.txt
python3 training/power_train.py --smoke          # proves real gradient steps

8. One-paragraph honest summary

XERO is a real, working, deterministic digital-organism framework with a genuinely-novel always-running inner core, wired to a real open-source LLM that is now being trained for real on the author's 500 books plus a genuinely free-to-use harvested corpus. The architecture, the tests, and the training are real and verifiable. It is early — not converged, not yet benchmarked, and intentionally honest about both. Use it as an advanced research prototype, judge it by the commands above, and watch the roadmap close.

⚓