Ryzova Alphi v1
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.
Model details
| Property | Specification |
|---|---|
| Model | Ryzova Alphi v1 |
| Developed by | Ryzova |
| Foundation | 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 |
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 | 3 Safetensors shards | ~9.51 GiB weight shards | Transformers on a compatible GPU |
| Alphi Q4_K_M | 4-bit GGUF | 3.182 GiB | Smaller-footprint local inference |
| Alphi Q6_K | 6-bit GGUF | 3.567 GiB | Mid-range quantization |
| Alphi Q8_0 | 8-bit GGUF | 4.608 GiB | Higher-precision quantization |
| Alphi 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:
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:
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 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 contains the published hashes.
Verified GGUF SHA256 values
3b7c50f30229ecb6bf221d2ee12238e08f4532724b46284490f3953bd2bce447 Ryzova-Alphi-v1-F16.gguf
a86073fe6e1c9b69a74f0727c06ad00de16547a121a793e46edc5f95ebacc8e4 Ryzova-Alphi-v1-Q4_K_M.gguf
e352a3acd38b51642e90e45c08738d9e7bed5990d8e0eca1def14b3e4ece46cf Ryzova-Alphi-v1-Q6_K.gguf
cf00612aaf32b16a226518aa3600e6aa24d50cb6eea37c9da159875cfca14bb7 Ryzova-Alphi-v1-Q8_0.gguf
Licensing
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.
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, LICENSE, and LICENSE-APACHE-2.0.txt. The neural-model download does not include our complete AI Wear source-code runtime.
Learn more
- 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
Cite Alphi
@misc{ryzova_alphi_v1_2026,
author = {{Ryzova}},
title = {Ryzova Alphi v1: Architecture, Persistent Memory, Retrieval, Tool Isolation, and Continual Skill Learning in a Modular Local-First AI System},
year = {2026},
doi = {10.5281/zenodo.22942971},
url = {https://doi.org/10.5281/zenodo.22942971}
}
Built by Ryzova. Designed for what comes next.
- Downloads last month
- 136