Publish Ryzova official voice Alphi v1 model card

README.md

@@ -16,125 +16,136 @@ tags:
   - fp16
   - gguf
   - local-first
-  - conversational
   - matrix-memory
   - growing-brain
+  - conversational
 ---
 
 <p align="center">
-  <img src="assets/alphi-alpha-mark.png" alt="Ryzova Alphi — Alpha Mark" width="280" />
+  <img src="assets/alphi-alpha-mark.png" alt="Ryzova Alphi Alpha Mark" width="220" />
 </p>
 
 <h1 align="center">Ryzova Alphi v1</h1>
 <p align="center"><strong>Beyond conversation. Toward personal intelligence.</strong></p>
-<p align="center">A local-first neural release with a broader vision for persistent memory, grounded knowledge, and validated reusable skills.</p>
+<p align="center">Built by Ryzova. Designed to grow beyond a single conversation.</p>
 
 <p align="center">
-  <a href="https://www.ryzova.com/">Ryzova</a> ·
-  <a href="https://www.ryzova.com/ai/alphi">About Alphi</a> ·
-  <a href="https://doi.org/10.5281/zenodo.22942971">Technical white paper</a> ·
-  <a href="https://huggingface.co/RyzovaTech/Alphi-v1/tree/main/gguf/v1">GGUF downloads</a>
+  <a href="https://www.ryzova.com/ai/alphi">Alphi</a> ·
+  <a href="https://www.ryzova.com/ai">Ryzova AI</a> ·
+  <a href="https://huggingface.co/RyzovaTech/Alphi-v1/tree/main/gguf/v1">Download GGUF</a> ·
+  <a href="https://doi.org/10.5281/zenodo.22942971">Technical paper</a>
 </p>
 
 ## Meet Alphi
 
-**Alphi v1** is Ryzova's first neural release for the **Alphi / AI Wear** ecosystem. Its released model is a **Ryzova Super-v8 adaptation of Google's Gemma 4 E2B-it**, distributed as **FP16 Safetensors** and **four GGUF variants** for local inference.
+**We built Alphi to move AI beyond isolated conversations.** Our goal is an assistant that can work with relevant context over time, ground answers in evidence, and build a library of useful, validated skills — while keeping the person using it in control.
 
-Alphi's wider vision is bigger than a chat model: **remember relevant context, distinguish old information from current facts, and reuse procedures that have passed validation**. Ryzova develops those capabilities through separate system technologies rather than claiming the neural weights learn new skills from every conversation.
+**Alphi v1** is our first neural release. It combines **Google's Gemma 4 E2B-it foundation** with our **Super-v8 neural adaptation**. We provide the merged model as **FP16 Safetensors** and four **GGUF** formats so developers can experiment with local inference.
 
-**What you get here:** the neural checkpoint and inference assets. **What belongs to the broader Alphi / AI Wear system:** Matrix Memory, Growing Brain, protected knowledge, document retrieval and controlled tools. Those need a separately integrated runtime; a standalone GGUF download does not activate them.
+The neural model is only one part of our design. Around it, we developed **Matrix Memory**, **Growing Brain**, **Ryzova Knowledge**, document retrieval, and controlled tools as distinct components of the wider **Alphi / AI Wear** system.
 
-### What makes the Alphi system distinctive?
+**This repository contains the neural model and its inference assets.** Our memory, skills, retrieval, and tool systems connect through a separate AI Wear runtime; they are not embedded inside a downloaded GGUF file.
 
-| Ryzova technology | In everyday terms | Design approach |
-|---|---|---|
-| **Matrix Memory** | Remember useful information and tell newer facts from old ones | Persistent structured records, provenance, and explicit supersession |
-| **Growing Brain** | Reuse a helpful workflow after it has been checked | Versioned procedural skills with evidence-based promotion and quarantine; no automatic neural weight retraining |
-| **Ryzova Knowledge** | Keep Ryzova/Alphi identity and lineage consistent | Protected first-party facts with trust-aware routing |
-| **Document RAG** | Answer questions from selected documents instead of guessing | Source-scoped retrieval and grounded evidence |
-| **Controlled tools** | Delegate exact calculations, file inspection and limited code tasks | Deterministic utilities and a restricted Python environment in the integrated runtime |
+## What we're building differently
+
+### Matrix Memory — memory with structure and history
+
+Conversations end. Useful context should not have to disappear with them.
+
+We designed **Matrix Memory** to store structured information outside the model's active context. It tracks source information, time, confidence, and relationships between records. When a fact changes, Matrix Memory can distinguish **current information from superseded history** rather than treating every stored statement as equally current.
+
+Our internal Matrix Memory v1.2.2 scale test ingested a **1,000,001-word synthetic corpus** and retrieved **5 of 5 planted sentinel facts**. This tests a particular retrieval workload, not perfect recall across arbitrary real-world documents.
+
+### Growing Brain — skills that earn their place
 
-**Examples from Ryzova's internal system tests:** Matrix Memory v1.2.2 retrieved **5/5 planted facts** from a **1,000,001-word synthetic test corpus**; Growing Brain used distinct validation evidence to promote reusable procedures and quarantine repeated failures. These results describe *specific internal AI Wear tests*, not universal recall or neural-model benchmark performance.
+**Growing Brain** is our system for developing a persistent library of reusable procedures.
 
-These are **Ryzova-developed system components**, not claims that every feature ships inside this neural-only repository. See the [Alphi overview](https://www.ryzova.com/ai/alphi) and [technical paper](https://doi.org/10.5281/zenodo.22942971) for the broader architecture.
+A procedure starts as a candidate, gathers distinct validation evidence, and can be promoted for later use. Updated procedures return to validation; repeatedly failing ones can be quarantined. This is **procedural learning outside neural weights**, not continuous retraining of the foundation model.
+
+### Ryzova Knowledge — a dependable identity layer
+
+**Ryzova Knowledge** protects core information about Alphi's identity, origin, and model lineage. It separates stable first-party facts from changing company information and lower-trust conversational content.
+
+### Document intelligence and controlled tools
+
+Our wider AI Wear architecture also connects **source-scoped document retrieval**, **deterministic calculations**, **file analysis**, and **restricted code execution**. Each component handles a task that should not depend entirely on a language model guessing the answer.
+
+**Our approach:** let the neural core generate and reason, let memory manage changing state, let retrieval bring evidence, and let validated skills and controlled tools support repeatable work.
+
+Learn more about the full architecture at [Ryzova Alphi](https://www.ryzova.com/ai/alphi).
 
 ## Model details
 
-| Property | Alphi v1 specification |
+| Property | Specification |
 |---|---|
-| Developer | **Ryzova** |
-| Neural foundation | **[Google Gemma 4 E2B-it](https://huggingface.co/google/gemma-4-E2B-it)** |
-| Neural adaptation | **Ryzova Super-v8**, parameter-efficient LoRA adaptation merged for deployment |
-| Earlier Ryzova research | Ryzova reports Qwen3.5 and Mistral 3 teacher/reference-model knowledge-distillation work; public training provenance is incomplete |
-| Parameters | About **2.3B effective / 5.1B total including embeddings** — inherited upstream Gemma 4 E2B figures |
-| Architecture | Gemma 4; **35** language-model layers (upstream) |
-| Context | **128K-token upstream configuration**; maximum useful Alphi context has **not** been independently evaluated |
-| Languages evaluated here | **English and Sinhala**, in limited engineering checks; not a multilingual benchmark |
-| Distribution | **FP16 Safetensors** and **F16, Q4_K_M, Q6_K, Q8_0 GGUF** |
-| Primary verified use | **Text generation** (FP16 and GGUF smoke tests) |
-| Multimodal status | Upstream Gemma 4 E2B-it supports text, image and audio inputs; Alphi v1 **GGUF multimodal operation is not verified** in this release evidence |
-| Licensing | **Component-specific**: Ryzova-authored code MPL-2.0; Google upstream Apache-2.0; details in [LICENSING.md](LICENSING.md) |
-
-The parameter count, layer count, and context configuration above describe the **underlying Gemma 4 E2B** architecture; they are not new Ryzova inventions or independent Alphi benchmark results.
-
-## Choose a checkpoint
-
-The **Q4_K_M GGUF** is the smallest listed download and a sensible starting point for experimenting with local text inference. Choose a higher-precision artifact when you have more memory available and want to evaluate the quality/performance trade-off on your own hardware.
-
-| Checkpoint | Format | File size | Suggested starting point |
+| Model | **Ryzova Alphi v1** |
+| Developed by | **Ryzova** |
+| Foundation | [Google Gemma 4 E2B-it](https://huggingface.co/google/gemma-4-E2B-it) |
+| Neural adaptation | **Ryzova Super-v8**, merged LoRA specialization |
+| Architecture | Gemma 4; **35 language-model layers** (upstream configuration) |
+| Parameters | Approximately **2.3B effective / 5.1B total**, including embeddings (upstream Gemma 4 E2B figures) |
+| Context configuration | **128K tokens** in the upstream configuration; Alphi's practical long-context performance requires separate testing |
+| Languages explored | **English and Sinhala** |
+| Formats | FP16 Safetensors; F16, Q4_K_M, Q6_K, Q8_0 GGUF |
+| Verified inference scope | Basic text generation and targeted smoke tests |
+| System technologies | Matrix Memory, Growing Brain, Ryzova Knowledge, Document RAG and controlled tools — through separate AI Wear integration |
+| Licensing | [Component-specific license information](LICENSING.md) |
+
+The upstream architecture specifications describe the **Gemma 4 E2B-it foundation**. Our work is the Super-v8 adaptation and the system technologies we develop around the neural model.
+
+## Choose your model
+
+We offer several formats to make experimentation easier. **Q4_K_M** is a practical first download for local text inference; higher-precision variants allow you to explore different quality and memory trade-offs.
+
+| Download | Format | Weight / file size | Where to start |
 |---|---|---:|---|
-| [FP16 neural model](https://huggingface.co/RyzovaTech/Alphi-v1/tree/main) | 3 Safetensors shards | ~9.51 GiB of weight shards | Transformers, compatible GPU environments |
-| [Q4_K_M](https://huggingface.co/RyzovaTech/Alphi-v1/blob/main/gguf/v1/Ryzova-Alphi-v1-Q4_K_M.gguf) | 4-bit GGUF | **3.182 GiB** | Smaller local text-inference footprint |
-| [Q6_K](https://huggingface.co/RyzovaTech/Alphi-v1/blob/main/gguf/v1/Ryzova-Alphi-v1-Q6_K.gguf) | 6-bit GGUF | **3.567 GiB** | Mid-range quantization option |
-| [Q8_0](https://huggingface.co/RyzovaTech/Alphi-v1/blob/main/gguf/v1/Ryzova-Alphi-v1-Q8_0.gguf) | 8-bit GGUF | **4.608 GiB** | Higher precision than smaller quantizations |
-| [F16 GGUF](https://huggingface.co/RyzovaTech/Alphi-v1/blob/main/gguf/v1/Ryzova-Alphi-v1-F16.gguf) | FP16 GGUF | **8.637 GiB** | Full-precision GGUF comparison |
+| [Alphi FP16](https://huggingface.co/RyzovaTech/Alphi-v1/tree/main) | 3 Safetensors shards | ~9.51 GiB weight shards | Transformers on a compatible GPU |
+| [Alphi Q4_K_M](gguf/v1/Ryzova-Alphi-v1-Q4_K_M.gguf) | 4-bit GGUF | **3.182 GiB** | Smaller-footprint local inference |
+| [Alphi Q6_K](gguf/v1/Ryzova-Alphi-v1-Q6_K.gguf) | 6-bit GGUF | **3.567 GiB** | Mid-range quantization |
+| [Alphi Q8_0](gguf/v1/Ryzova-Alphi-v1-Q8_0.gguf) | 8-bit GGUF | **4.608 GiB** | Higher-precision quantization |
+| [Alphi F16 GGUF](gguf/v1/Ryzova-Alphi-v1-F16.gguf) | FP16 GGUF | **8.637 GiB** | Full-precision GGUF comparison |
 
-**Hardware note:** File size is **not** total runtime memory. Available RAM/VRAM, KV cache, context length, backend, offloading, and other software affect whether an artifact will fit and how fast it will run. These formats have **not** been benchmarked on every phone, laptop, or desktop.
+These are **artifact sizes**, not total runtime memory requirements. RAM/VRAM use depends on context length, KV cache, runtime, offloading, and hardware.
 
-### Quick start — GGUF with llama.cpp
+## Quick start
 
-Install a recent `llama.cpp` build with Gemma 4 support. Its executable may be called `llama-completion` or live under `build/bin/` depending on your build.
+### Local GGUF inference with llama.cpp
 
-**1. Download** one verified GGUF file:
+Install a recent `llama.cpp` build supporting Gemma 4. The following is a text-only example using our Q4_K_M release:
 
 ```bash
 hf download RyzovaTech/Alphi-v1 \
   gguf/v1/Ryzova-Alphi-v1-Q4_K_M.gguf \
   --local-dir ./alphi
-```
-
-**2. Run a small text prompt** (CPU-only example):
 
-```bash
 llama-completion \
   -m ./alphi/gguf/v1/Ryzova-Alphi-v1-Q4_K_M.gguf \
-  --jinja --reasoning off --single-turn \
-  -p 'Compute 84 + 126. Reply only with the integer.' \
-  -n 128 -c 2048 -t 4 -ngl 0 --temp 0
+  --jinja --reasoning off \
+  -p 'What is 84 + 126? Answer with the number only.' \
+  -n 128
 ```
 
-This command follows the style of Ryzova's November 2026 engineering smoke tests; flag support can depend on your `llama.cpp` version. A GPU-enabled build can use hardware offloading when supported. **These GGUF tests validate text inference only**, not an integrated AI Wear agent or multimodal pipeline.
+Our GGUF smoke tests used a `llama.cpp` build with `--jinja --reasoning off`. Available executable names and flags depend on your build. This example runs the **neural model**, not the complete AI Wear runtime.
 
-### Quick start — FP16 with Transformers
+### FP16 with Transformers
 
-For a Gemma 4-compatible Transformers environment with enough GPU memory, this is a starting **text-generation example**. Actual memory requirements depend on your environment; the release's internal FP16 cold boot was performed on a Tesla T4.
+Our merged FP16 model is also available for use with a compatible Gemma 4 Transformers environment. Start with the repository's model and processor assets:
 
 ```python
 import torch
 from transformers import AutoProcessor, AutoModelForMultimodalLM
 
-repo = "RyzovaTech/Alphi-v1"
-
-processor = AutoProcessor.from_pretrained(repo)
+model_id = "RyzovaTech/Alphi-v1"
+processor = AutoProcessor.from_pretrained(model_id)
 model = AutoModelForMultimodalLM.from_pretrained(
-    repo,
+    model_id,
     dtype=torch.float16,
     device_map="auto",
 )
 
 messages = [{
     "role": "user",
-    "content": [{"type": "text", "text": "What is 84 + 126? Answer briefly."}],
+    "content": [{"type": "text", "text": "What is 84 + 126?"}],
 }]
 
 inputs = processor.apply_chat_template(
@@ -148,93 +159,73 @@ inputs = {k: v.to(model.device) if hasattr(v, "to") else v
           for k, v in inputs.items()}
 
 with torch.inference_mode():
-    generated = model.generate(**inputs, max_new_tokens=64, do_sample=False)
+    output = model.generate(**inputs, max_new_tokens=64, do_sample=False)
 
-new_tokens = generated[0, inputs["input_ids"].shape[-1]:]
-print(processor.tokenizer.decode(new_tokens, skip_special_tokens=True))
+answer = output[0, inputs["input_ids"].shape[-1]:]
+print(processor.tokenizer.decode(answer, skip_special_tokens=True))
 ```
 
-The example follows the upstream Gemma 4 multimodal-loading pattern, adapted to this repository; **this exact code block has not been separately certified as a release test**. Update Transformers and follow its [Gemma 4 documentation](https://huggingface.co/docs/transformers/model_doc/gemma4) if your installed version differs.
-
-## Neural model and AI Wear: how they fit together
-
-Alphi has a **neural layer** and a **separate system layer**. Both are part of Ryzova's Alphi architecture, but they are distributed differently:
+This is an illustrative integration example, not a separately validated release test for every Transformers version. A compatible Transformers release and sufficient hardware memory are required. Our internal FP16 cold boot used an NVIDIA Tesla T4.
 
-| Layer | Role | Availability in this repository |
-|---|---|---|
-| **Alphi Super-v8 neural core** | Generates and interprets text, supports model experiments | **Included:** FP16 and GGUF weights |
-| **Matrix Memory + Growing Brain** | Persistent structured memory and validated reusable skills | **AI Wear runtime component:** separate integration required |
-| **Ryzova Knowledge + Document RAG** | Stable first-party product facts and source-grounded document answers | **AI Wear runtime component:** separate integration required |
-| **Deterministic tools + restricted sandbox** | Exact operations and controlled code execution | **AI Wear runtime component:** separate integration required |
-
-**Why split them?** A model's neural parameters should not be treated as a database. Matrix Memory tracks changing facts; Growing Brain manages validated procedures; the neural core generates responses based on the evidence supplied by the host system. A `.gguf` or `.safetensors` file alone does not include the separate memory database, skill store, retrieval indexes, or execution services.
+## Our development path
 
-The [Ryzova white paper](https://doi.org/10.5281/zenodo.22942971) documents internal AI Wear integration tests under specific conditions. Those system-level results are **not benchmarks of the standalone GGUF model**.
+Alphi did not begin with this single checkpoint. **Our early Alphi R&D included knowledge-distillation work with Qwen3.5 and Mistral 3.** Those experiments were part of the research path toward the Alphi system.
 
-## Training and model lineage
+For the **v1 neural model we are releasing here**, we selected **Google Gemma 4 E2B-it** and our **Super-v8 LoRA adaptation**. We merged that adaptation into the FP16 model and prepared GGUF variants for local use.
 
-Alphi's development history and the released neural checkpoint are related, but **not the same thing**.
-
-| Stage | What it means | Evidence status |
-|---|---|---|
-| **Early Ryzova research** | Ryzova reports knowledge-distillation work involving **Qwen3.5** and **Mistral 3** as teacher/reference models during Alphi's beginnings | **Ryzova-reported history**; teacher checkpoints, data receipts and exact training runs are not documented in the archived Super-v8 release reviewed here |
-| **Released foundation** | Google's instruction-tuned **Gemma 4 E2B-it** supplies the base architecture and starting weights | **Identified** in the archived release provenance and model configuration |
-| **Ryzova specialization** | **Super-v8** LoRA adaptation for the Alphi v1 neural core | **Identified** in the archived adapter provenance and technical white paper |
-| **Deployment export** | Merged FP16 neural checkpoint plus F16, Q4_K_M, Q6_K and Q8_0 GGUF variants | **Verified** by the recorded release hashes and smoke tests |
+The earlier distillation work describes **our development history**, not a claim that Qwen or Mistral weight tensors are merged into the downloadable Gemma-derived checkpoint. We are not attaching exact teacher checkpoints, dataset receipts, or teacher-run logs to this release, so we do not present numerical teacher-distillation results here.
 
-**Distillation clarification:** The Qwen3.5 / Mistral 3 reference describes Ryzova's **reported research process**, **not** a claim that their neural weights were merged into the released model or that the public Super-v8 package independently proves those teacher-training runs. A fuller distillation provenance record would identify exact teacher versions, generated datasets or targets, permissions and training evidence. It is not yet included in this release.
+Our technical paper documents the Super-v8 adapter configuration:
 
-The frozen **Super-v8** adapter is described in the Ryzova technical white paper:
-
-| Adapter detail | Recorded value |
+| Super-v8 detail | Recorded configuration |
 |---|---:|
 | Technique | LoRA |
-| Rank / alpha / dropout | 4 / 8 / 0.05 |
-| Recorded trainable LoRA parameters | 1,339,392 |
-| Covered language-model layers | 35 |
-| Distribution | Adapter merged into FP16 model weights; GGUF files generated from the frozen checkpoint |
-
-The paper also discusses synthetic prompt generation, experimental branches and internal validation. Those artifacts do **not** establish that every listed dataset or teacher-model output was used to train the frozen Super-v8 checkpoint. The released weights remain **Gemma-derived**; the more detailed research history is attributed to Ryzova until its underlying training records are published.
+| Rank | 4 |
+| Alpha | 8 |
+| Dropout | 0.05 |
+| Trainable LoRA parameters | 1,339,392 |
+| Language-model layers covered | 35 |
 
-**Provenance:** The frozen original FP16 neural revision is `ffb73bca5c8c34623c6cec19767289fcce797d3b` in Ryzova's private engineering archive. This clean public-distribution repository deliberately excludes development backup files and the archive's previous Git history.
+Read the [Alphi technical white paper](https://doi.org/10.5281/zenodo.22942971) for the architecture and archived engineering methodology.
 
-## Evaluation and performance
+## What we've tested
 
-### What has been checked
+We believe in showing what we tested — and keeping that separate from what we intend to build next.
 
-| Test / evidence | Recorded result | What it means |
+| Test | Result | Scope |
 |---|---|---|
-| FP16 checkpoint cold boot | **PASS** — 1,951 tensors loaded across 3 shards | The frozen neural model loaded in the recorded engineering environment |
-| GGUF text inference: basic math | **4/4** formats returned `210` for `84 + 126` | Small, deterministic smoke test — **not** a math benchmark |
-| GGUF Sinhala text generation | **4/4** formats produced a Sinhala response | Targeted language-generation check — **not** a Sinhala proficiency score |
-| Q6_K short Python response | Generated a simple string-reversal function | Narrow coding example — **not** an agentic coding benchmark |
-| Historical internal neural Frozen-200 | **73.88 overall; formal gate not passed** | Internal development metric; not an external benchmark or a cross-model comparison |
-| Historical AI Wear integration suites | **54/54** core checks and **51/51** final integrated checks reported in the white paper | Tests of a **separately integrated system**, not of GGUF weights alone |
+| Frozen FP16 cold boot | **PASS** — 1,951 tensors, 3 shards | Recorded neural load and basic generation |
+| GGUF simple arithmetic | **4/4 PASS** | All four formats answered `84 + 126 = 210` |
+| GGUF Sinhala generation | **4/4 PASS** | Small text-generation smoke test |
+| Q6_K coding prompt | **PASS** | A short Python string-reversal example |
+| AI Wear Core Intelligence suite | **54/54** in archived internal tests | Separate integrated runtime, not GGUF weights |
+| AI Wear final integration suite | **51/51** in archived internal tests | Separate system-level checks |
+| Matrix Memory million-word test | **5/5** planted sentinels | Synthetic retrieval-scale experiment |
+
+Our earlier **Frozen-200 internal neural evaluation** recorded an overall score of **73.88** and **did not pass its formal release gate**. We preserve that result in the white paper rather than turning it into an external benchmark claim.
+
+We have **not published comparable external scores** for MMLU-Pro, GPQA, IFEval, SWE-bench, LiveCodeBench or BFCL for this checkpoint. The upstream 128K context configuration, multimodal features, and device-specific performance are not independently established as Alphi v1 results by these tests.
 
-**Not yet established:** Public, comparable scores for MMLU-Pro, GPQA, IFEval, LiveCodeBench, SWE-bench, BFCL, external safety evaluations, long-context retrieval at 128K, phone/laptop latency, and end-to-end multimodal GGUF performance. No numbers from Google Gemma 4 or any other model are presented as Alphi's own results.
+## What's included — and what connects separately
 
-### Is Alphi better than other models?
+**Included in this download:** merged neural weights, model configuration, tokenizer/processor assets, chat template, GGUF files, checksum manifest, model card, Alpha Mark, and license notices.
 
-There is **no independently comparable leaderboard evidence in this release** that supports a superiority claim. File sizes, internal smoke tests and system-layer validation do not support comparisons with Liquid AI, Qwen, Gemma, or other systems. Publish head-to-head scores only after running named public evaluations under reproducible settings.
+**Connected through AI Wear:** Matrix Memory, Growing Brain, Ryzova Knowledge, Document RAG, deterministic utilities, file analysis, and the restricted Python sandbox.
 
-## Intended uses and limitations
+This separation is intentional. We can update memory records, evaluate skills, or change retrieved evidence **without pretending that the model weights are continuously retrained**. An app must explicitly integrate the relevant AI Wear components to use them.
 
-**Good starting uses:** local model exploration; human-reviewed drafting and explanation; short programming examples; English/Sinhala text experiments; and building apps that explicitly integrate their own memory, retrieval or tool layers.
+## Responsible use
 
-**Do not assume:** reliable autonomous coding agents; built-in personal memory or tool calls; unrestricted device or browser control; guaranteed 128K usable context; complete language fluency; or safety in medical, legal, financial and other high-stakes decisions.
+Alphi v1 is a starting point for **local text-generation experiments, developer exploration, English/Sinhala interaction, drafting, coding assistance and research into memory-aware AI applications**.
 
-- Generative output can be incorrect, biased, incomplete or inconsistent; check important facts and execute/test generated code before relying on it.
-- Local deployment does not automatically guarantee privacy: the host application, permissions, storage, logs and network settings matter.
-- A restricted execution wrapper reduces risk but is not proof of universal sandbox security.
-- GGUF conversions have been smoke-tested for **text**; do not infer image/audio or tool compatibility without separate testing.
-- Real-world speed and RAM/VRAM requirements vary with model format, hardware, inference backend and context size.
+Generated text can be inaccurate or biased. Test code before running it; verify important facts; and keep human review for medical, legal, financial, security-sensitive or other consequential uses. Local model files do not automatically guarantee an application's privacy, security or tool permissions. We have not established broad autonomous-agent performance, 128K long-context reliability, or end-to-end image/audio GGUF support with this release.
 
 ## File integrity
 
-All four GGUF files were compared against recorded SHA256 values both locally and in the private Hugging Face release-candidate upload. The clean release repository was then server-side copied and **all four remote GGUF hashes passed again**. The three FP16 weight shards were also matched by SHA256 to their pinned source objects. The checksum manifest is at [`gguf/v1/GGUF_SHA256SUMS.txt`](gguf/v1/GGUF_SHA256SUMS.txt).
+We verified the four GGUF files by remote SHA256 and matched the three FP16 shards against the frozen source. The [GGUF checksum manifest](gguf/v1/GGUF_SHA256SUMS.txt) contains the published hashes.
 
 <details>
-<summary>GGUF SHA256 values (click to expand)</summary>
+<summary>Verified GGUF SHA256 values</summary>
 
 ```text
 3b7c50f30229ecb6bf221d2ee12238e08f4532724b46284490f3953bd2bce447  Ryzova-Alphi-v1-F16.gguf
@@ -242,30 +233,23 @@ a86073fe6e1c9b69a74f0727c06ad00de16547a121a793e46edc5f95ebacc8e4  Ryzova-Alphi-v
 e352a3acd38b51642e90e45c08738d9e7bed5990d8e0eca1def14b3e4ece46cf  Ryzova-Alphi-v1-Q6_K.gguf
 cf00612aaf32b16a226518aa3600e6aa24d50cb6eea37c9da159875cfca14bb7  Ryzova-Alphi-v1-Q8_0.gguf
 ```
-
 </details>
 
-## Licensing and attribution
-
-This distribution contains material governed by **different licenses and rights holders**. The licenses do not replace each other.
+## Licensing
 
-| Material | License / notice |
-|---|---|
-| **Ryzova-owned source code**, wherever separately distributed | **Mozilla Public License 2.0 (MPL-2.0)**; see [`LICENSE`](LICENSE) |
-| **Google Gemma 4 E2B-it upstream weights/architecture** | **Apache License 2.0** as published by Google; see [`LICENSE-APACHE-2.0.txt`](LICENSE-APACHE-2.0.txt) |
-| **Alphi merged FP16 and GGUF weights** | Derived from the Google base and Ryzova neural modifications; consult [`LICENSING.md`](LICENSING.md) for scope, attribution, modification notice and redistribution terms |
+We license **Ryzova-owned source code** under **Mozilla Public License 2.0 (MPL-2.0)**. The **Google Gemma 4 E2B-it foundation** is distributed under **Apache License 2.0**, subject to Google's upstream terms and notices. Our merged weights are derived from that foundation and include Ryzova modifications.
 
-The Hugging Face `license: other` field is used to point readers to the **component-specific distribution notices**; it should not be interpreted as replacing Google's Apache-2.0 terms or automatically applying MPL-2.0 to all neural weights. The clean model release does **not** ship the entire AI Wear source-code kit. Consult the license files for binding terms.
+Because these components have different applicable rights and notices, this repository uses Hugging Face's `license: other` metadata and explains the distribution in [`LICENSING.md`](LICENSING.md), [`LICENSE`](LICENSE), and [`LICENSE-APACHE-2.0.txt`](LICENSE-APACHE-2.0.txt). The neural-model download does not include our complete AI Wear source-code runtime.
 
-## Research, documentation and citation
+## Learn more
 
-- **Ryzova:** https://www.ryzova.com/
-- **About Alphi:** https://www.ryzova.com/ai/alphi
-- **Technical paper:** [*Ryzova Alphi v1: Architecture, Persistent Memory, Retrieval, Tool Isolation, and Continual Skill Learning in a Modular Local-First AI System*](https://doi.org/10.5281/zenodo.22942971) (23 September 2026)
-- **Foundation model:** [google/gemma-4-E2B-it](https://huggingface.co/google/gemma-4-E2B-it)
-- **License details:** [LICENSING.md](LICENSING.md)
+- **Official Alphi page:** https://www.ryzova.com/ai/alphi
+- **Ryzova AI:** https://www.ryzova.com/ai
+- **Ryzova website:** https://www.ryzova.com/
+- **Technical white paper:** https://doi.org/10.5281/zenodo.22942971
+- **Upstream Gemma 4 E2B-it:** https://huggingface.co/google/gemma-4-E2B-it
 
-If you reference the broader system architecture, cite the Ryzova technical white paper:
+### Cite Alphi
 
 ```bibtex
 @misc{ryzova_alphi_v1_2026,
@@ -279,5 +263,4 @@ If you reference the broader system architecture, cite the Ryzova technical whit
 
 ---
 
-<p align="center"><strong>Ryzova Alphi v1</strong> · Built for a local-first, modular AI future.</p>
-<p align="center"><em>Neural model release · AI Wear integrations documented separately · 2 November 2026</em></p>
+<p align="center"><strong>Built by Ryzova. Designed for what comes next.</strong></p>