Beyond conversation. Toward personal intelligence.
Built by Ryzova. Designed to grow beyond a single conversation.
Alphi · Ryzova AI · Download GGUF · Technical paper
## Meet Alphi **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 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. 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. **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. ## 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 **Growing Brain** is our system for developing a persistent library of reusable procedures. 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 | Specification | |---|---| | 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** | | 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 | |---|---|---:|---| | [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 | These are **artifact sizes**, not total runtime memory requirements. RAM/VRAM use depends on context length, KV cache, runtime, offloading, and hardware. ## Quick start ### Local GGUF inference with llama.cpp 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 llama-completion \ -m ./alphi/gguf/v1/Ryzova-Alphi-v1-Q4_K_M.gguf \ --jinja --reasoning off \ -p 'What is 84 + 126? Answer with the number only.' \ -n 128 ``` 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. ### FP16 with Transformers 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 model_id = "RyzovaTech/Alphi-v1" processor = AutoProcessor.from_pretrained(model_id) model = AutoModelForMultimodalLM.from_pretrained( model_id, dtype=torch.float16, device_map="auto", ) messages = [{ "role": "user", "content": [{"type": "text", "text": "What is 84 + 126?"}], }] inputs = processor.apply_chat_template( messages, tokenize=True, add_generation_prompt=True, return_dict=True, return_tensors="pt", ) inputs = {k: v.to(model.device) if hasattr(v, "to") else v for k, v in inputs.items()} with torch.inference_mode(): output = model.generate(**inputs, max_new_tokens=64, do_sample=False) answer = output[0, inputs["input_ids"].shape[-1]:] print(processor.tokenizer.decode(answer, skip_special_tokens=True)) ``` 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. ## Our development path 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. 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. 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. Our technical paper documents the Super-v8 adapter configuration: | Super-v8 detail | Recorded configuration | |---|---:| | Technique | LoRA | | Rank | 4 | | Alpha | 8 | | Dropout | 0.05 | | Trainable LoRA parameters | 1,339,392 | | Language-model layers covered | 35 | Read the [Alphi technical white paper](https://doi.org/10.5281/zenodo.22942971) for the architecture and archived engineering methodology. ## What we've tested We believe in showing what we tested — and keeping that separate from what we intend to build next. | Test | Result | Scope | |---|---|---| | 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. ## What's included — and what connects separately **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. **Connected through AI Wear:** Matrix Memory, Growing Brain, Ryzova Knowledge, Document RAG, deterministic utilities, file analysis, and the restricted Python sandbox. 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. ## Responsible use 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**. 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 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.Built by Ryzova. Designed for what comes next.