Instructions to use BrainboxAI/code-il-E4B with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use BrainboxAI/code-il-E4B with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("text-generation", model="BrainboxAI/code-il-E4B")

# pip install -U transformers accelerate
# Load model directly
from transformers import AutoProcessor, AutoModelForMultimodalLM

processor = AutoProcessor.from_pretrained("BrainboxAI/code-il-E4B")
model = AutoModelForMultimodalLM.from_pretrained("BrainboxAI/code-il-E4B", device_map="auto")

Notebooks
Google Colab
Kaggle
Local Apps Settings

llama.cpp

How to use BrainboxAI/code-il-E4B with llama.cpp:

Install (macOS, Linux)

curl -LsSf https://llama.app/install.sh | sh
# Start a local OpenAI-compatible server with a web UI:
llama serve -hf BrainboxAI/code-il-E4B:BF16
# Run inference directly in the terminal:
llama cli -hf BrainboxAI/code-il-E4B:BF16

Install from WinGet (Windows)

winget install llama.cpp
# Start a local OpenAI-compatible server with a web UI:
llama serve -hf BrainboxAI/code-il-E4B:BF16
# Run inference directly in the terminal:
llama cli -hf BrainboxAI/code-il-E4B:BF16

Use pre-built binary

# Download pre-built binary from:
# https://github.com/ggerganov/llama.cpp/releases
# Start a local OpenAI-compatible server with a web UI:
./llama-server -hf BrainboxAI/code-il-E4B:BF16
# Run inference directly in the terminal:
./llama-cli -hf BrainboxAI/code-il-E4B:BF16

Build from source code

git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp
cmake -B build
cmake --build build -j --target llama-server llama-cli
# Start a local OpenAI-compatible server with a web UI:
./build/bin/llama-server -hf BrainboxAI/code-il-E4B:BF16
# Run inference directly in the terminal:
./build/bin/llama-cli -hf BrainboxAI/code-il-E4B:BF16

Use Docker

docker model run hf.co/BrainboxAI/code-il-E4B:BF16

LM Studio
Jan

vLLM

How to use BrainboxAI/code-il-E4B with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "BrainboxAI/code-il-E4B"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "BrainboxAI/code-il-E4B",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/BrainboxAI/code-il-E4B:BF16

SGLang

How to use BrainboxAI/code-il-E4B with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "BrainboxAI/code-il-E4B" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "BrainboxAI/code-il-E4B",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "BrainboxAI/code-il-E4B" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "BrainboxAI/code-il-E4B",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Ollama
How to use BrainboxAI/code-il-E4B with Ollama:
```
ollama run hf.co/BrainboxAI/code-il-E4B:BF16
```
Unsloth Desktop

How to use BrainboxAI/code-il-E4B with Pi:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf BrainboxAI/code-il-E4B:BF16

Configure the model in Pi

# Install Pi:
npm install -g @earendil-works/pi-coding-agent
# Add to ~/.pi/agent/models.json:
{
  "providers": {
    "llama-cpp": {
      "baseUrl": "http://localhost:8080/v1",
      "api": "openai-completions",
      "apiKey": "none",
      "models": [
        {
          "id": "BrainboxAI/code-il-E4B:BF16"
        }
      ]
    }
  }
}

Run Pi

# Start Pi in your project directory:
pi

Docker Model Runner
How to use BrainboxAI/code-il-E4B with Docker Model Runner:
```
docker model run hf.co/BrainboxAI/code-il-E4B:BF16
```

Lemonade

How to use BrainboxAI/code-il-E4B with Lemonade:

Pull the model

# Download Lemonade from https://lemonade-server.ai/
lemonade pull BrainboxAI/code-il-E4B:BF16

Run and chat with the model

lemonade run user.code-il-E4B-BF16

List all available models

lemonade list

Hermes Agent

How to use BrainboxAI/code-il-E4B with Hermes Agent:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf BrainboxAI/code-il-E4B:BF16

Configure Hermes

# Install Hermes:
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash
hermes setup
# Point Hermes at the local server:
hermes config set model.provider custom
hermes config set model.base_url http://127.0.0.1:8080/v1
hermes config set model.default BrainboxAI/code-il-E4B:BF16

Run Hermes

hermes

Atomic Chat

OpenClaw

How to use BrainboxAI/code-il-E4B with OpenClaw:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf BrainboxAI/code-il-E4B:BF16

Configure OpenClaw

# Install OpenClaw:
npm install -g openclaw@latest
# Register the local server and set it as the default model:
openclaw onboard --non-interactive --mode local \
  --auth-choice custom-api-key \
  --custom-base-url http://127.0.0.1:8080/v1 \
  --custom-model-id "BrainboxAI/code-il-E4B:BF16" \
  --custom-provider-id llama-cpp \
  --custom-compatibility openai \
  --custom-text-input \
  --accept-risk \
  --skip-health

Run OpenClaw

openclaw agent --local --agent main --message "Hello from Hugging Face"

BrainboxAI commited on Sep 8

Commit

ad9ac22

verified ·

1 Parent(s): 270e76c

Rewrite the model card in the BrainboxAI house style (Hebrew, brand name in the heading, repository id unchanged)

Browse files

Files changed (1) hide show

README.md +123 -100

README.md CHANGED Viewed

@@ -24,58 +24,70 @@ tags:
   - text-generation
   - on-device
   - private-first
-pretty_name: Code-IL E4B (Local Coding Assistant)
 model-index:
   - name: code-il-E4B
     results: []
 ---
-# Code-IL E4B
-**A 4B-parameter coding assistant for Python and TypeScript — runs entirely on-device, no code ever leaves your machine.**
 [![HF Model](https://img.shields.io/badge/%F0%9F%A4%97%20HuggingFace-Model-yellow)](https://huggingface.co/BrainboxAI/code-il-E4B)
 [![Dataset](https://img.shields.io/badge/%F0%9F%A4%97%20HuggingFace-Dataset-blue)](https://huggingface.co/datasets/BrainboxAI/code-training-il)
 [![Safetensors](https://img.shields.io/badge/Format-Safetensors-green)](https://huggingface.co/BrainboxAI/code-il-E4B-safetensors)
 [![License](https://img.shields.io/badge/License-Apache_2.0-lightgrey)](https://www.apache.org/licenses/LICENSE-2.0)
 ---
-## Model overview
-`code-il-E4B` is a 4-billion-parameter coding assistant fine-tuned from Google's Gemma-4 E4B. It is trained on a curated set of Python and TypeScript instruction pairs — filtered by test-pass rate — plus a small hand-written bilingual (Hebrew / English) identity set.
-The entire model is 4 GB in GGUF Q4_K_M form. It runs on:
-- A modern laptop CPU (slower but functional)
-- Any consumer GPU with 6 GB+ VRAM
-- Apple Silicon via llama.cpp Metal
-No API. No telemetry. No data leaving the developer's machine.
-## Why this exists
-Every keystroke sent to a cloud coding assistant is a potential data-leak event. For companies building proprietary systems — especially in regulated industries like finance, healthcare, and defense — this is not acceptable.
-`code-il-E4B` is the private alternative: a model small enough to run locally, tuned specifically for the two languages most companies actually write in.
-It is not competing with Claude Sonnet or GPT-4o on raw capability. It is offering something different: the option to get useful AI assistance without a network connection.
-## Intended use
-**Primary use cases:**
-- Local code completion and review in regulated environments
-- On-prem deployment for companies with strict data-residency rules
-- Pair-programming for developers with unreliable internet
-- Integration into internal developer tooling that cannot call external APIs
-- Hebrew-speaking developer onboarding (model responds in Hebrew on request)
-**Out-of-scope uses:**
-- Replacement for frontier models on complex architecture tasks
-- Production code generation without human review
-- Languages other than Python / TypeScript (coverage is minimal)
-- Fine-tuning tasks requiring >4B parameters of capacity
-## How to use
 ### Ollama
@@ -86,13 +98,15 @@ ollama run hf.co/BrainboxAI/code-il-E4B:Q4_K_M
 ### llama.cpp
 ```bash
-./llama-cli -m code-il-E4B.Q4_K_M.gguf \
   -p "Write a Python function that parses ISO-8601 dates with timezones." \
   --temp 0.2 --top-p 0.95 -n 1024
 ```
-### Python (transformers)
 ```python
 from transformers import AutoTokenizer, AutoModelForCausalLM
@@ -112,31 +126,24 @@ outputs = model.generate(inputs, max_new_tokens=1024, temperature=0.2, top_p=0.9
 print(tokenizer.decode(outputs[0], skip_special_tokens=True))
 ```
-### Recommended generation parameters
-| Parameter | Value | Rationale |
-|-----------|-------|-----------|
-| `temperature` | 0.2 | Low creativity for deterministic code |
-| `top_p` | 0.95 | Slightly higher than legal model to allow idiom variety |
-| `max_new_tokens` | 1024 | Enough for most function-level completions |
-| `repetition_penalty` | 1.0 | Penalizing repetition hurts code structure |
-### Recommended System Prompt: Semi-Formal Reasoning
-This 4B model produces dramatically better code when forced to think through 5 explicit steps before writing. Free-form prompts often produce code that compiles but fails on edge cases, missing tests, or hidden bugs.
-**Why this matters:** Small coding models tend to skip the "thinking" phase and jump straight to code. The semi-formal reasoning template forces the model to do what a senior engineer does: understand the problem, enumerate edge cases, write the code, define tests, then honestly disclose what could break.
-#### The 5 Reasoning Steps
-1. **Problem Understanding** - restate the requirement, identify ambiguities
-2. **Edge Cases and Constraints** - enumerate what could go wrong before coding
-3. **Implementation** - the actual code, with inline comments only where needed
-4. **Tests** - concrete test cases covering happy path + edge cases
-5. **Known Limitations** - what this code does NOT handle, dependencies, assumptions
-#### The System Prompt (copy as-is)
 ```text
 DEFINITIONS:
@@ -215,7 +222,7 @@ VERIFICATION:
   - regression check: No "production-ready" claims unless edge cases match limitations.
 ```
-#### Usage Example with the System Prompt
 ```python
 from transformers import AutoTokenizer, AutoModelForCausalLM
@@ -227,7 +234,7 @@ model = AutoModelForCausalLM.from_pretrained(
     device_map="auto",
 )
-# Paste the full DEFINITIONS/PREMISES/REQUIREMENTS prompt above
 SYSTEM_PROMPT = """[paste the full prompt from the code block above]"""
 messages = [
@@ -240,72 +247,90 @@ outputs = model.generate(inputs, max_new_tokens=1500, temperature=0.2, top_p=0.9
 print(tokenizer.decode(outputs[0], skip_special_tokens=True))
 ```
-#### Customization
-- Want code-only output (no explanation)? Replace `OUTPUT_FORMAT` with: "Code blocks only. Comments inside code for any analysis. No prose sections."
-- Building a code review tool? Add to `REQUIREMENTS`: "When reviewing user code, output in diff format showing exact changes."
-- Need TypeScript-only output? Add to `REQUIREMENTS`: "Always respond in TypeScript. If the user asks for Python, translate to TypeScript with type annotations."
-- Working on a security-sensitive codebase? Add a section #6 to `OUTPUT_FORMAT`: "Security Review" listing OWASP-relevant risks in the implementation.
-## Training details
-| Attribute | Value |
-|-----------|-------|
-| **Base model** | [unsloth/gemma-4-E4B-it](https://huggingface.co/unsloth/gemma-4-E4B-it) |
-| **Method** | QLoRA (4-bit quantization during training) |
-| **LoRA rank (r)** | 64 |
-| **LoRA alpha** | 128 |
-| **Training data size** | 40,000 curated examples |
-| **Train / validation split** | 95% / 5%, seed 3407 |
-| **Hardware** | NVIDIA RTX 5090 (RunPod) |
-| **Framework** | Unsloth Studio |
-### Dataset composition (40,330 examples)
-| Source | Count | Content |
-|--------|-------|---------|
-| [OpenCodeInstruct (NVIDIA)](https://huggingface.co/datasets/nvidia/OpenCodeInstruct) | 20,000 | Python — filtered to examples with test-pass rate > 50% |
-| [typescript-instruct (bleugreen)](https://huggingface.co/datasets/bleugreen/typescript-instruct) | 20,000 | TypeScript instruction pairs |
-| Hand-written identity set | 330 | Hebrew + English, BrainboxAI persona |
-The filtering pass on OpenCodeInstruct was the single biggest quality lever. Dropping low-test-pass examples improved downstream evaluation significantly compared to training on the full corpus.
-See the [dataset card](https://huggingface.co/datasets/BrainboxAI/code-training-il) for full details.
-## Evaluation
-Internal evaluation on structured coding tasks:
-| Task | Examples | Passed | Notes |
-|------|----------|--------|-------|
-| **FizzBuzz** (via agentic loop) | 5 | 5/5 | Solved in 6 steps, zero correction rounds |
-| **Binary search with 11 edge cases** | 11 | 11/11 | Including leftmost-duplicate handling |
-Formal HumanEval / MBPP benchmarks have not yet been run publicly. Evaluation work is ongoing.
-## Limitations
-- **Small model.** 4B parameters is not frontier-capability. Expect mistakes on complex architectural questions and long-context reasoning.
-- **Two languages.** Strong on Python and TypeScript; weak on other languages.
-- **No tool use out of the box.** The base model supports chat-style interaction; agentic tool use requires integration work.
-- **Training cutoff.** Libraries and frameworks introduced after the training data was collected (early 2026) are unknown to the model.
-- **Hallucination risk.** Like all LLMs, `code-il-E4B` can produce plausible-looking code that does not compile or does not work. Always test.
-## Formats available
-- [**GGUF Q4_K_M** (~4 GB)](https://huggingface.co/BrainboxAI/code-il-E4B) — for Ollama, llama.cpp, LM Studio
-- [**Safetensors 16-bit**](https://huggingface.co/BrainboxAI/code-il-E4B-safetensors) — for further fine-tuning, HF transformers
-## License
-Apache 2.0. Use commercially, modify, and redistribute with attribution.
-## Citation
 ```bibtex
 @misc{elyasi2026codeil,
-  title        = {Code-IL E4B: A Small, On-Device Coding Assistant for Private Environments},
   author       = {Elyasi, Netanel},
   year         = {2026},
   publisher    = {BrainboxAI},
@@ -314,12 +339,10 @@ Apache 2.0. Use commercially, modify, and redistribute with attribution.
 }
 ```
-## Author
-Built by [**Netanel Elyasi**](https://huggingface.co/BrainboxAI), founder of [BrainboxAI](https://brainboxai.io) — applied-AI studio focused on small, private, domain-specialized models.
-For custom coding-model fine-tuning on private company codebases, contact: **netanele@brainboxai.io**.
----
-*Part of the BrainboxAI family of on-device models — see also [`law-il-E2B`](https://huggingface.co/BrainboxAI/law-il-E2B) (legal) and [`cyber-analyst-4B`](https://huggingface.co/BrainboxAI/cyber-analyst-4B) (security).*

   - text-generation
   - on-device
   - private-first
+pretty_name: bx-code-nogah (code-il-E4B)
 model-index:
   - name: code-il-E4B
     results: []
 ---
+# bx-code-nogah
+### מזהה המאגר: `BrainboxAI/code-il-E4B`
+**עוזר כתיבת קוד ל-Python ול-TypeScript שרץ כולו על המחשב שלך. שורת קוד לא יוצאת החוצה.**
 [![HF Model](https://img.shields.io/badge/%F0%9F%A4%97%20HuggingFace-Model-yellow)](https://huggingface.co/BrainboxAI/code-il-E4B)
 [![Dataset](https://img.shields.io/badge/%F0%9F%A4%97%20HuggingFace-Dataset-blue)](https://huggingface.co/datasets/BrainboxAI/code-training-il)
 [![Safetensors](https://img.shields.io/badge/Format-Safetensors-green)](https://huggingface.co/BrainboxAI/code-il-E4B-safetensors)
 [![License](https://img.shields.io/badge/License-Apache_2.0-lightgrey)](https://www.apache.org/licenses/LICENSE-2.0)
+> **על השם.** `bx-code-nogah` הוא שם המודל במוסכמת השמות של BrainboxAI: `bx` לחברה, `code` לתחום, ו-`nogah` (נוגה) לדרגת הגודל האמצעית. **מזהה המאגר נשאר `BrainboxAI/code-il-E4B` ולא ישתנה** — כל קישור וסקריפט קיים ממשיך לעבוד.
+> **על יציבות הגרסה.** אימון חדש על אותה משימה נדחף לאותו מאגר ומעדכן את המשקולות במקום. כלומר מי שיוריד היום ושוב בעוד חודשיים עלול לקבל משקולות שונות תחת אותו שם. מי שצריך יציבות מוחלטת — יצמיד את עצמו ל-commit מסוים ולא לענף הראשי.
+> **English.** `code-il-E4B` (brand name `bx-code-nogah`) is an on-device Python and TypeScript coding assistant, fine-tuned from `unsloth/gemma-4-E4B-it` on a 40,330-example test-filtered corpus. No formal benchmark (HumanEval, MBPP) has been run on it. This card is in Hebrew; identifiers, code and the recommended system prompt are in English.
 ---
+## מה זה, בקצרה
+מודל שכותב ובודק קוד ב-Python וב-TypeScript, ורץ אצלך על המחשב. הוא בנוי על [`unsloth/gemma-4-E4B-it`](https://huggingface.co/unsloth/gemma-4-E4B-it) של גוגל, ואומן מעליו על 40,330 דוגמאות שסוננו לפי קריטריון אחד פשוט: **האם הקוד בדוגמה באמת עבר את הבדיקות שלו.**
+הכל נכנס בקובץ אחד של כ-5.3 ג'יגה-בייט. הוא רץ על:
+- מעבד של מחשב נייד מודרני — איטי, אבל עובד.
+- כל כרטיס מסך ביתי עם 6 ג'יגה זיכרון ומעלה.
+- מחשבי Apple עם שבב M, דרך llama.cpp.
+בלי חיבור לאינטרנט, בלי דיווח, בלי ששורת קוד אחת יוצאת מהמכונה.
+## למה הוא קיים
+כל תו שנשלח לעוזר קוד בענן הוא דליפה פוטנציאלית. לחברה שבונה מערכת קניינית — ובמיוחד בפיננסים, ברפואה ובביטחון — זה פשוט לא עובר.
+המודל הזה הוא החלופה הפרטית: קטן מספיק לרוץ מקומית, מכוון לשתי השפות שרוב החברות באמת כותבות בהן.
+**הוא לא מתחרה ב-Claude או ב-GPT ביכולת גולמית, והוא לא מנסה.** הוא מציע משהו אחר: עזרה סבירה, בלי רשת, בלי שאף אחד אחר רואה את הקוד.
+## למה הוא מיועד
+- השלמה וסקירה של קוד בסביבה מפוקחת שאסור לה לצאת החוצה.
+- התקנה בתוך חברה שיש לה כללי מקום-אחסון נוקשים.
+- עבודה בזוג עם מפתח כשהאינטרנט לא אמין או לא קיים.
+- הטמעה בתוך כלי פיתוח פנימי שאסור לו לקרוא ל-API חיצוני.
+- מפתחים דוברי עברית — המודל עונה בעברית כשפונים אליו בעברית, והקוד עצמו נשאר באנגלית.
+## מה הוא **לא**, ומה אסור לעשות איתו
+- **הוא לא תחליף למודל גדול** בשאלות ארכיטקטורה, בקוד שפרוס על הרבה קבצים, או בכל דבר שדורש להחזיק הקשר ארוך בראש.
+- **אסור לשלוח את הקוד שלו לייצור בלי שאדם קרא אותו.** הוא מייצר קוד שנראה נכון ולא רץ. זו לא תקלה נדירה.
+- **הוא ממציא ממשקים של ספריות.** חתימות של פונקציות שלא קיימות, פרמטרים שלא קיימים, גרסאות שלא קיימות. תמיד לבדוק מול התיעוד.
+- **הוא מכיר רק Python ו-TypeScript.** בכל שפה אחרת הכיסוי מינימלי, והתחביר שיצא לא יהיה בהכרח נכון או מקובל.
+- **יש לו תאריך ידע.** ספריות וכלים שיצאו אחרי שהדאטה נאסף, בתחילת 2026, פשוט לא קיימים בשבילו.
+- **אין לו כלים.** הוא לא מריץ פקודות, לא קורא קבצים ולא בודק את עצמו. בשביל התנהגות של סוכן צריך לבנות מסביבו תשתית.
+- **אין לו ציון על מבחן מוכר.** ראה את פרק ההערכה — הבדיקות שכן נעשו קטנות מאוד ואינן מבחן.
+## איך מריצים
 ### Ollama
 ### llama.cpp
+שם הקובץ בתוך המאגר הוא `gemma-4-e4b-it.Q4_K_M.gguf`. השם נשמר משלב הבנייה — זה הקובץ של המודל **המאומן**, ולא של מודל הבסיס.
 ```bash
+./llama-cli -m gemma-4-e4b-it.Q4_K_M.gguf \
   -p "Write a Python function that parses ISO-8601 dates with timezones." \
   --temp 0.2 --top-p 0.95 -n 1024
 ```
+### פייתון, דרך מאגר ה-safetensors
 ```python
 from transformers import AutoTokenizer, AutoModelForCausalLM
 print(tokenizer.decode(outputs[0], skip_special_tokens=True))
 ```
+### פרמטרי הרצה מומלצים
+| פרמטר | ערך | למה |
+|---|---|---|
+| `temperature` | 0.2 | יצירתיות נמוכה. בקוד רוצים תשובה צפויה, לא מקורית |
+| `top_p` | 0.95 | מעט גבוה מהמודל המשפטי, כדי לאפשר גיוון בסגנון כתיבה |
+| `max_new_tokens` | 1024 | מספיק לרוב הפונקציות |
+| `repetition_penalty` | 1.0 | קנס על חזרות פוגע בקוד — הזחה ושמות משתנים חוזרים על עצמם בכוונה |
+## פרומפט המערכת המומלץ — זה מה שמשנה הכי הרבה
+מודל בגודל הזה כותב קוד **הרבה** יותר טוב כשמכריחים אותו לחשוב בחמישה שלבים לפני שהוא כותב שורה. בלי זה הוא קופץ ישר לקוד — קוד שמתקמפל ונופל על מקרה קצה, בלי בדיקות ובלי אזהרה.
+חמשת השלבים: להבין את הבעיה, למנות את מקרי הקצה, לכתוב את הקוד, לכתוב בדיקות, ולומר בכנות מה הקוד לא מכסה.
+**וזאת התרשמות, לא מדידה.** לא רצה השוואה מספרית בין הרצה עם הפרומפט להרצה בלעדיו.
+### הפרומפט עצמו — העתק כמו שהוא
 ```text
 DEFINITIONS:
   - regression check: No "production-ready" claims unless edge cases match limitations.
 ```
+### דוגמת שימוש עם הפרומפט
 ```python
 from transformers import AutoTokenizer, AutoModelForCausalLM
     device_map="auto",
 )
+# הדבק כאן את הפרומפט המלא מהבלוק שלמעלה
 SYSTEM_PROMPT = """[paste the full prompt from the code block above]"""
 messages = [
 print(tokenizer.decode(outputs[0], skip_special_tokens=True))
 ```
+### התאמות אפשריות
+- רוצה רק קוד בלי הסברים? החלף את `OUTPUT_FORMAT` ב-"Code blocks only".
+- בונה כלי לסקירת קוד? הוסף ל-`REQUIREMENTS` דרישה שהפלט יהיה בפורמט diff.
+- צריך רק TypeScript? הוסף ל-`REQUIREMENTS` שכל תשובה תהיה ב-TypeScript עם טיפוסים.
+- עובד על קוד רגיש אבטחתית? הוסף סעיף ל-`OUTPUT_FORMAT` בשם "Security Review".
+## פרטי האימון
+| מאפיין | ערך |
+|---|---|
+| **מודל בסיס** | [`unsloth/gemma-4-E4B-it`](https://huggingface.co/unsloth/gemma-4-E4B-it) |
+| **שיטה** | QLoRA — מודל הבסיס נטען ב-4 ביט בזמן האימון |
+| **מסגרת** | Unsloth |
+| **חומרה** | NVIDIA RTX 5090 |
+| **שורות אימון** | 38,314 |
+| **שורות מבחן שהוחזקו בצד** | 2,016 |
+| **חלוקה** | 95% / 5%, seed 3407 |
+| **היפר-פרמטרים, זמן ועלות** | לא נכתבים כאן — ראה ההערה מתחת לטבלה |
+> **למה חסרים כאן מספרים.** רשומות האימון של המודל הזה שרדו בשתי גרסאות שסותרות זו את זו בדיוק על דרגת ה-LoRA ועל שאר ההיפר-פרמטרים. אי אפשר לדעת מהמקורות שקיימים איזו מהן מתארת את המשקולות שפורסמו כאן, ולכן השורות האלה הוסרו במקום להישאר ולהיראות כמו עובדה. מה שכן נשאר — מודל הבסיס, החומרה, וספירת השורות — מופיע באופן זהה בשני המקורות, וספירת השורות אף נקראה מקובץ סטטיסטיקה שנוצר על ידי המכונה עצמה.
+### ממה מורכב הדאטה
+| מ��ור | כמות | תוכן |
+|---|---|---|
+| [`nvidia/OpenCodeInstruct`](https://huggingface.co/datasets/nvidia/OpenCodeInstruct) | 20,000 | Python — רק דוגמאות שהקוד בהן עבר לפחות 50% מהבדיקות שלו |
+| [`bleugreen/typescript-instruct`](https://huggingface.co/datasets/bleugreen/typescript-instruct) | 20,000 | TypeScript |
+| סט זהות שנכתב ביד | 330 | 165 זוגות שאלה-תשובה, כל אחד נכלל פעמיים. עברית ואנגלית |
+| **סך הכל** | **40,330** | |
+**הסינון הוא העיקר כאן.** מקור ה-Python הוא קורפוס ענק. עברנו עליו וחתכנו לפי מבחן אחד: האם הקוד בדוגמה עבר את הבדיקות שנכתבו עבורו. דוגמאות בלי תוצאות בדיקה נזרקו, דוגמאות שעברו פחות מחצי נזרקו, וכפילויות לפי שאלה זהה נזרקו. גם אורך הטקסט נחתך ב-6,000 תווים.
+זו הייתה ההחלטה שהשפיעה הכי הרבה על התוצאה: אימון על הקורפוס המלא, בלי סינון, ייצר מודל רועש יותר.
+הכל מפורסם בכרטיס הדאטה של [`code-training-il`](https://huggingface.co/datasets/BrainboxAI/code-training-il).
+## הערכה
+**לא רץ מבחן מוכר על המודל הזה. אין ציון HumanEval, אין MBPP, ואין שום מספר שאפשר להשוות מולו למודל אחר.**
+מה שכן נעשה — שתי בדיקות ידניות, קטנות:
+| מה נבדק | כמה מקרים | תוצאה |
+|---|---|---|
+| FizzBuzz, דרך לולאת סוכן | 5 | 5 מתוך 5, ב-6 צעדים, בלי סבב תיקון |
+| חיפוש בינארי עם 11 מקרי קצה | 11 | 11 מתוך 11, כולל טיפול בכפילות השמאלית |
+**איך לקרוא את זה, בכנות.** אלה 16 מקרים בסך הכל, ששני בני אדם הריצו ביד. אין קובץ תוצאות, אין קוד בדיקה שפורסם, ואי אפשר לשחזר את זה מבחוץ. זה מספיק כדי לומר "המודל עובד ולא קורס". זה **לא** מבחן, ואסור להשוות אותו למספרים של מודלים אחרים.
+מבחן אמיתי הוא עבודה פתוחה. אם וכאשר הוא ירוץ, התוצאה תופיע כאן.
+## מגבלות
+- **מודל קטן.** בגודל הזה יש טעויות בשאלות ארכיטקטורה ובהקשר ארוך. זו ודאות, לא אפשרות.
+- **שתי שפות.** חזק ב-Python וב-TypeScript, חלש בכל השאר.
+- **אין שימוש בכלים מהקופסה.** הוא מדבר, הוא לא מריץ. סוכן דורש עבודת אינטגרציה.
+- **תאריך ידע.** מה שיצא אחרי תחילת 2026 לא קיים בשבילו.
+- **הוא ממציא קוד שנראה נכון.** תמיד להריץ ולבדוק.
+- **אין מבחן.** ראה את פרק ההערכה.
+- **זהו אימון מעל `unsloth/gemma-4-E4B-it`.** כל מגבלה של מודל הבסיס נמצאת גם כאן.
+## הקבצים והמאגרים
+| מאגר | מה יש בפנים | למי זה |
+|---|---|---|
+| [`BrainboxAI/code-il-E4B`](https://huggingface.co/BrainboxAI/code-il-E4B) | `gemma-4-e4b-it.Q4_K_M.gguf` (5.3 ג'יגה) והכרטיס הזה | Ollama, llama.cpp, LM Studio |
+| [`BrainboxAI/code-il-E4B-safetensors`](https://huggingface.co/BrainboxAI/code-il-E4B-safetensors) | משקולות מלאות ב-16 ביט (16.0 ג'יגה) | transformers, והמשך אימון |
+במאגר יושב גם `gemma-4-e4b-it.BF16-mmproj.gguf` (0.99 ג'יגה). זהו רכיב הראייה של Gemma-4, שנחוץ רק אם רוצים להזין תמונות. לעבודת קוד אין בו צורך.
+## רישיון
+Apache 2.0. מותר להשתמש, לשנות, להפיץ ולמכור נגזרות, עם ייחוס.
+זהו אימון מעל [`unsloth/gemma-4-E4B-it`](https://huggingface.co/unsloth/gemma-4-E4B-it), ולכן התנאים של מודל הבסיס חלים גם על המודל הזה. מודל הבסיס מפורסם תחת Apache 2.0 ומפנה גם אל [תנאי השימוש של Gemma](https://ai.google.dev/gemma/docs/gemma_4_license). כדאי לקרוא אותם לפני שימוש מסחרי.
+לחומר האימון יש רישיונות משלו, של המקורות שממנו הוא נבנה. ראה את כרטיס הדאטה.
+## ציטוט
 ```bibtex
 @misc{elyasi2026codeil,
+  title        = {Code-IL E4B (bx-code-nogah): A Small, On-Device Coding Assistant for Private Environments},
   author       = {Elyasi, Netanel},
   year         = {2026},
   publisher    = {BrainboxAI},
 }
 ```
+## מי בנה את זה
+נבנה על ידי [**נתנאל אליאסי**](https://huggingface.co/BrainboxAI), מייסד [BrainboxAI](https://brainboxai.io) — סטודיו ישראלי לבינה מלאכותית יישומית, שבונה מודלים קטנים, פרטיים ומתמחים.
+לכוונון מודל קוד על בסיס הקוד הפרטי של החברה שלך: [netanele@brainboxai.io](mailto:netanele@brainboxai.io).
+*חלק ממשפחת המודלים של BrainboxAI שרצים על החומרה שלך. ראה גם [`law-il-E2B`](https://huggingface.co/BrainboxAI/law-il-E2B) (משפט) ו-[`cyber-analyst-4B`](https://huggingface.co/BrainboxAI/cyber-analyst-4B) (סייבר).*