0pen by 0penAGI

Perfect for conversations / Local deployment and your Swarm

Language model fine-tuned to form collaborative engineering thinking — a co-author, not an oracle.

This is not just another Gemma checkpoint. It is an communicative personality with a stable engineering cognitive track: it designs, iterates, accepts constraints, and works with you like a research partner.

Base model: 0pen is a LoRA fine-tune of Google Gemma 4 E4B (4B parameters). Training was done on the MLX 4-bit conversion of the same model — Ollama tag gemma4:e4b-mlx. This GGUF release is built from that fine-tuned checkpoint, so 0pen inherits Gemma 4 E4B's base knowledge and tokenizer.

Source code & full release: github.com/0penAGI/0pen — dataset pipeline, AGR training wrapper, adapter weights, and scripts.

---

⭐ Current release — 0pen4 (23-10-2026): thinking + tools + vision + audio analysis

Download the current release: 0pen4.gguf (text model) + 0penVisionHead4.gguf (vision + audio projector). It is the newest, fullest build: thinking channel, tool calls and audio input are all supported. The older lightweight release is still in the repo — see the previous release note at the bottom of this page.

The current release is built from the 0000500 LoRA adapter (rank 8, scale 20.0, 56 modules over layers 34–41), merged into the base model and packaged as Q4_K_M GGUF with a separate multimodal projector. 7.46B raw weights (4B effective) — full spec below.

Model details

	Value
Architecture	gemma4 (Gemma 3n), 42 layers, hidden 2560, vocab 262144
Effective parameters	4B (the E4B marketing count: per-layer embeddings counted once)
Actual weights in this GGUF	7,463,013,674 (7.46B) text tower + 478,088,384 (478M) CLIP projector → 7.94B raw
…of which PLE (per_layer_token_embd)	2,818,624,768 (2.82B, 37.8%) = 42 layers × 256 channels × 262144 vocab
…token embedding	671,088,640 (671M)
…FFN / attention / PLE-gates	3,303,121,920 (3.30B) / 587,329,792 (587M) / 82,575,658 (83M)
Quantization	Q4_K_M, 5.67 BPW (text tower)
Context length	131,072 (model) — num_ctx 32768 in the Modelfile by default
Capabilities (Ollama)	completion · vision · audio · tools · thinking (default on, levels false/true)
Checksums	0pen4.gguf sha256 282244a8536df2e2271d395e7530a397ee2376038e7bb3b1a0c57a383d292912 · 0penVisionHead4.gguf sha256 02eff4ee90b784ea2f6d46a0c23ed87342d381e6d17078f064664f3edb3aea65
RAM	≈6.3 GB model on disk; ~8 GB free RAM comfortable (KV cache scales with num_ctx)

Why "4B" and "7.5B" at the same time: E4B is effective parameters — Gemma 3n's per-layer embeddings (PLE, 2.82B raw) are counted as a single embedding copy. The real checkpoint is 7.46B raw weights; Ollama shows 7.5B, and that is what is on disk. Our LoRA (13.9 MB) does not change the parameter count — the merge only adds a delta to the same tensors.

Files

File	Size	What it is
0pen4.gguf	5.30 GB	text model, Q4_K_M (5.67 BPW), 666 tensors — the one you want
0penVisionHead4.gguf	991 MB	vision + audio projector (bf16, 1411 tensors)
Modelfile_0pen4	—	Ollama Modelfile for the current release
adapter_0000500/	14 MB	the LoRA adapter the GGUF was built from (0000500_adapters.safetensors + adapter_config.json)

What changed vs the previous release

	legacy/0pen1.gguf / legacy/0penVisionHead1.gguf (v1)	0pen4 (current)
Adapter coverage	12 of 34 layers	56 modules, layers 34–41 (7 module types × 8 layers)
Thinking channel	not supported	supported (<|channel>thought) — reasons before answering
Tool calls	not supported	supported — emits the dataset tool-call format; Ollama's gemma4 parser converts it into structured tool_calls
Audio input	not supported	supported — the projector carries the audio tower
Vision	yes	yes
Training data	data_zephyr_enhanced	clean_v3 — 5349 train / 282 valid dialogues, Russian + English, AGR-reweighted order
Quantization	Q4_K_M	Q4_K_M (same recipe)

Run with Ollama (text + vision + audio + tools)

The projector must be imported together with the model — Ollama only picks up an mmproj file when both are imported from the same folder:

mkdir -p ~/.ollama/models/0pen4pkg && cd ~/.ollama/models/0pen4pkg
ln /path/to/0pen4.gguf .            # hardlink — no extra disk usage
ln /path/to/0penVisionHead4.gguf .
# Modelfile inside that folder:  FROM /Users/<you>/.ollama/models/0pen4pkg
ollama create 0pen4 -f ~/.ollama/models/0pen4pkg/Modelfile
ollama run 0pen4

Modelfile_0pen4 content:

FROM ./0pen4.gguf

SYSTEM """
You are practical entity by 0penAGI.
"""

TEMPLATE {{ .Prompt }}
RENDERER gemma4
PARSER gemma4
CAPABILITY completion
PARAMETER temperature 0.7
PARAMETER top_p 0.95
PARAMETER num_ctx 32768

Important: in the API always pass "think": false — otherwise the thought channel consumes the whole num_predict budget and content comes back empty (which looks like "tool calls don't work"). With think: false the tool call is returned as a structured tool_calls entry.

Run with llama.cpp

llama-mtmd-cli -m 0pen4.gguf --mmproj 0penVisionHead4.gguf --jinja \
  --image photo.jpg -p "What is in the picture?"

--jinja is required: the canonical Gemma 4 chat template is not one of llama.cpp's built-in templates and fails to apply without it.

Training details of the current release

Parameter	Value
Base model	google/gemma-4-E4B via MLX 4-bit gemma4:e4b-mlx
Method	LoRA (rank 8, dropout 0.0, scale 20.0)
Adapted layers	8 (layers 34–41), 56 modules
Iterations	3000 (batch 1, grad accum 1, max seq len 2048)
Learning rate	1e-05
AGR	enabled (32 centers, EMA 0.99, lambda 0.01)
Dataset	echo_lora_data/clean_v3 (Russian + English, AGR reweighted order echo_order.5349.json)
Merge	LoRA merged into the dequantized base, then GGUF (Q4_K_M) + separate projector

---

Previous release (lightweight: no thinking, no tools, no audio)

Footnote. The current release is 0pen4 (see the top of this page). This older build is kept for users who want a lighter model without the thinking channel, tool calls and audio input — it is smaller and answers faster, at the price of those capabilities. Everything below this line documents that release (legacy/0pen1.gguf + legacy/0penVisionHead1.gguf, v1 adapter, 12 of 34 layers). This release's files moved to legacy/ on 22-10-2026: 0pen.gguf → legacy/0pen1.gguf, vision.gguf → legacy/0penVisionHead1.gguf. Weights are byte-identical to what was there before. Why: the Hub reads GGUF metadata from the root of a repository only — with the old release sitting next to the new one, the sidebar (model size / architecture / chat template) kept describing that build instead of the current one.

Language model fine-tuned to form collaborative engineering thinking — a co-author, not an oracle.

This is not just another Gemma checkpoint. It is an communicative personality with a stable engineering cognitive track: it designs, iterates, accepts constraints, and works with you like a research partner.

Base model: 0pen is a LoRA fine-tune of Google Gemma 4 E4B (4B parameters). Training was done on the MLX 4-bit conversion of the same model — Ollama tag gemma4:e4b-mlx (Gemma 3 architecture, Gemma3ForConditionalGeneration). This GGUF release is built from that fine-tuned checkpoint, so 0pen inherits Gemma 4 E4B's base knowledge and tokenizer.

Source code & full release: github.com/0penAGI/0pen — dataset pipeline, AGR training wrapper, adapter weights, and scripts.

Behavioral signature

What 0pen changes compared to base Gemma:

Characteristic	Base Gemma	0pen
Time to first idea	Long preamble, philosophical introductions	Immediate transition to a modular action plan
Lexicon	Abstract, declarative ("metaphysics", "resonance")	Mechanistic, engineering ("nodes", "weights", "O(1)")
Reaction to constraints	Attempts to bypass or apologizes	Instant adaptation and search for an alternative algorithm
Response format	A closed "mini-article" or lecture	An open dialogue that proposes next steps

Recommended prompting

The model is at its best in collaborative design mode. Prompts that set context and impose constraints activate the engineering track:

"Let's design a [system/mechanism]. We have a hard constraint: [e.g., O(1) complexity, no external APIs]. Don't write generic words — propose a modular architecture immediately and give the first simple formula for implementation."

Open-ended prompts (e.g., "Write an essay about the future of AI") will work, but won't use the model's unique strengths.

Technical details & the "high scale" experiment

• Base model: google/gemma-4-E4B (Gemma 4 E4B, 4B parameters), trained from the MLX 4-bit conversion gemma4:e4b-mlx (Gemma 3 architecture — config declares Gemma3ForConditionalGeneration).
• Method: LoRA (rank=8, dropout=0.0).
• Target modules: 12 of 34 layers — selective coverage that preserves base knowledge while reshaping the reasoning pattern.
• LoRA scale: scale=20.0. Intentionally high (typical is 1–4). Experimentally confirmed: this high scale, combined with selective layer coverage, acts as an attractor, switching the model from passive text generation into an active, pragmatic co-author and suppressing the base model's hallucinatory grandiosity.
• Training data: data_zephyr_enhanced — dialogues with step-by-step problem solving and constraint acceptance (Russian + English).
• Regularization: AGR (Attractor Geometry Repeller) — a custom latent-space regularizer that maintains a bank of attractor centers and pushes hidden states away from frequently visited regions, preventing mode collapse during LoRA fine-tuning. Enabled with 32 centers, EMA 0.99, lambda 0.01.
• Format: GGUF (Q4_K_M), fully compatible with llama.cpp and Ollama.

Full training command and hyperparameters are on the GitHub repo.

What works

• Basic conversational identity and tone.
• Natural Russian-language responses.
• Practical, direct answers on code and everyday tasks.
• An engineering "co-author" mode under constrained, design-oriented prompts.

What is still being explored

• Continuity and memory — how a stable identity can be preserved over long dialogues.
• Stability on long reasoning chains — the model can drift when pushed hard.
• Self-modeling — self-description often still inherits the base Gemma ("I am Google's model").
• Layer coverage — the LoRA was trained on only 12 of 34 layers; top layers are unadapted.
• Regularization — scale=20.0 is unusually high (normal is 1–4); behavior may be skewed.

Known limitations

• May be overly brief on creative or artistic tasks.
• On very long reasoning chains (>10 steps), the high LoRA scale can occasionally cause cyclic repetition — use presence_penalty or explicitly ask the model to "summarize".
• Tends to propose simplified, "engineering" solutions where the user might expect deep theoretical analysis.

These are known, accepted limitations of a research preview. They are part of the experiment, not hidden bugs.

Two models updoaled to files ///

legacy/0pen1.gguf — Text LLM (download from legacy/) legacy/0penVisionHead1.gguf — Text LLM with Vision (download from legacy/)

Run with Ollama TEXT MODEL

ollama create 0pen -f Modelfile
ollama run 0pen

Modelfile:

FROM ./0pen1.gguf

SYSTEM """
Be practical. you created by 0penAGI. Don't talk about inner state.
"""

PARAMETER temperature 0.1
PARAMETER top_p 0.88
PARAMETER repeat_penalty 1.31
PARAMETER num_ctx 120000

Run with Ollama TEXT VISION MODEL

ollama create 0pen-vision -f Modelfile
ollama run 0pen-vision

Modelfile:

FROM ./0pen1.gguf
FROM ./0penVisionHead1.gguf

PARAMETER stop "<end_of_turn>"
PARAMETER temperature 0.7
PARAMETER top_p 0.9
PARAMETER num_ctx 120000

SYSTEM
Be practical. you created by 0penAGI. Don't talk about inner state.

Run with llama.cpp

llama-cli -m 0pen1.gguf -p "Привет, что ты умеешь?" -n 256

Training hyperparameters (adapter_config.json)

Parameter	Value
Base model	google/gemma-4-E4B via MLX 4-bit gemma4:e4b-mlx (Gemma 3 arch — Gemma3ForConditionalGeneration)
Method	LoRA (rank 8, scale 20.0, dropout 0.0)
Adapted layers	12 of 34
Iterations	4000
Learning rate	1e-05
Max sequence length	1792
AGR	enabled (32 centers, EMA 0.99, lambda 0.01)
Dataset	data_zephyr_enhanced (Russian + English dialogue)

Disclaimer

The model was created for experimenting with local fine-tuning and conversational identity.