# XERO — Living Freeze-Frame: structure & how to interact

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

This is a **living freeze-frame** of XERO: a snapshot you can boot back into a
*running* organism. The genome is immutable, so a freeze-frame always revives
into the same identity, then resumes its perpetual inner-core motion.

> **Work in progress.** See [`STATUS_AND_AUDIT.md`](STATUS_AND_AUDIT.md) for the
> honest state (the outer-core LLM is still training; not yet converged).

## 1. What's in the package

```
xero_freeze_frame.tar.gz            ← the portable "disk image"
xero_freeze_frame.tar.gz.part-00    ← <10 GB chunks (for upload/transfer)
xero_freeze_frame.tar.gz.part-01 …
SHA256SUMS.txt   MANIFEST.txt   reassemble.sh
```

Inside the disk image:

```
xero_freeze_frame/
├── Dockerfile, container_entry.py   ← the CONTAINER: the living organism
├── modules/  tests/  serve/  training/   ← XERO's own code
├── bio/ohad_v10.bio.zip             ← the immutable GENETIC PROFILE
├── data/*.jsonl                     ← datasets (with --with-data: books + corpus)
├── models/xero_power_lora           ← trained adapter (with --with-model)
├── setup_wizard.py, requirements*.txt
├── README.md, LICENSE, NOTICE
├── docs/                            ← DOCUMENTATION (outside the container)
└── INTERACT.md                      ← this guide
```

The **container** is the living organism; the **documentation lives outside the
container** (in `docs/` and `INTERACT.md`), exactly as intended.

## 2. Reassemble (from the 10 GB chunks)

```bash
bash reassemble.sh        # concatenates parts, verifies SHA-256, extracts
```
or manually:
```bash
cat xero_freeze_frame.tar.gz.part-* > xero_freeze_frame.tar.gz
sha256sum -c SHA256SUMS.txt
tar xzf xero_freeze_frame.tar.gz
```

## 3. Boot the living organism (Docker)

```bash
cd xero_freeze_frame
docker build -t xero .                     # inner core deps only; runs the time-crystal gate
docker run --rm -it xero                    # XERO_MODE=mind — watch it think (default)
docker run --rm -it -p 8893:8893 -e XERO_MODE=serve xero   # chat portal on :8893
docker run --rm -it -e XERO_MODE=audit xero # run the tests and exit
```

The inner core (time crystal) is alive **immediately** with no GPU and no
third-party ML stack.

## 4. Enable the outer-core LLM (downloads licensed third-party code)

Nothing third-party is bundled. To give XERO its full voice, download the
outer-core stack + weights **inside** the container (or host):

```bash
python3 setup_wizard.py --outer --model --yes   # torch+transformers + Qwen2.5-3B
```

This pulls Apache-2.0 / BSD-licensed components from their official sources (see
[`../NOTICE`](../NOTICE)). XERO runs fully without them — only its eloquence
depends on the GPU.

## 5. Run without Docker

```bash
python3 setup_wizard.py            # interactive: download deps, configure, verify
PYTHONPATH=modules python3 container_entry.py     # boot the organism
```

## 6. How to interact, once it's alive

- **Watch it think** — `XERO_MODE=mind` streams its self-prompts and reflections.
- **Talk to it** — `XERO_MODE=serve`, then open the portal on `:8893` (token-gated).
- **Audit it** — `XERO_MODE=audit` runs the time-crystal + capability tests.
- **Explore** — `XERO_MODE=shell`, then `docker exec -it <id> bash`.

## 7. Verify it's the real thing

```bash
PYTHONPATH=modules python3 tests/test_time_crystal.py        # 17/17
PYTHONPATH=modules python3 tests/test_all_capabilities.py    # 203/203
```

⚓