ZYR3 — AI Coding Agent Platform

An AI coding agent and code generation system. Write code, fix bugs, and build software with ZYR3.

Try it now

Live browser demo, no install needed:

Space demo: https://huggingface.co/spaces/zyr-AGENT/zyr3-demo

What ZYR3 Actually Is

ZYR3 is a multi-AI model: a single interface powered by 34 specialized models routed per task. It is built on top of GLM (the GLM family via the Z.ai SDK, all MIT-licensed) with a custom model layer on top: ZSMLLMCP (our distilled 1B/3B/7B CPU-only models) plus the ULTRA Coding Prompt system. Default inference delegates to the ZYR3 API (no local GPU required), so this repo ships no required weights — from_pretrained loads without any weight files. ZYR3 adds:

Base — GLM family — GLM 5.3 / 5.2 / 5.1 / 4.6 / 4 Plus / 4 Air / 4 Flash / 4 FlashX (MIT-licensed Big Thanks to Zhipu Ai
Top — ZSMLLMCP — our distilled local model layer (1B/3B/7B, CPU-only, MIT) trained on GLM-family output
Top — ULTRA Coding Prompt — A system prompt that makes the base model reason like a senior engineer
14 Language Specialists — Language-specific prompt injection (Python, Rust, TS, Go, etc.)
34 Model Router — model.ts auto-routes tasks between models using token/context/output-token limits (up to 8,192 output tokens)
Self-correcting workflow — Writes code, runs it, sees the errors, and fixes them in an iterative loop
Code-first design — Optimized for code generation, debugging, and refactoring, not just chat

Use cases: code generation, AI pair programming, code review, bug fixing, test generation, and software engineering automation.

Use this model

Load ZYR3 like any standard Hugging Face model. No GPU and no local weights — inference is served by the free ZYR3 API.

Hugging Face Transformers

from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("zyr-AGENT/zyr3", trust_remote_code=True)
tokenizer = AutoTokenizer.from_pretrained("zyr-AGENT/zyr3", trust_remote_code=True)

inputs = tokenizer("Write a Python web server", return_tensors="pt")
outputs = model.generate(**inputs, max_new_tokens=512)
print(tokenizer.decode(outputs[0]))

Note: uses trust_remote_code=True because ZYR3 ships custom model code (modeling_zyr3.py).

Other ways to use ZYR3

Tool	How to use
Google Colab	Ready-to-run notebook + one-command download → Google Colab
LM Studio	OpenAI-compatible server on `http://localhost:1234/v1` → LM Studio / OpenAI-compatible
vLLM	`vllm serve "zyr-AGENT/zyr3" --trust-remote-code`
VS Code	Install `zyr3-vscode-extension.vsix`

vLLM serve

vllm serve "zyr-AGENT/zyr3" --trust-remote-code

curl -X POST "http://localhost:8000/v1/completions" \
  -H "Content-Type: application/json" \
  --data '{"model": "zyr-AGENT/zyr3", "prompt": "Hello", "max_tokens": 512}'

VS Code Extension

Download zyr3-vscode-extension.vsix → Install in VSCode.

Installation

Requirements: Python 3.8 or newer (the bridge uses only the Python standard library).

Install the LM Studio bridge / OpenAI-compatible server (any OS)

# Fetch the script straight from this repo
wget -q https://huggingface.co/zyr-AGENT/zyr3/resolve/main/zyr3_lmstudio.py

# Start ZYR3 on http://127.0.0.1:1234/v1
python zyr3_lmstudio.py

Then point any OpenAI-compatible client at http://localhost:1234/v1 (see the LM Studio section below). Press Ctrl+C to stop. To install the script permanently:

sudo cp zyr3_lmstudio.py /usr/local/bin/zyr3-lmstudio
sudo chmod +x /usr/local/bin/zyr3-lmstudio
zyr3-lmstudio

Install ZYR3 Lite (compressed, unlimited)

ZYR3 Lite is the small-footprint, fast, unlimited edition. It bridges OpenRouter to an OpenAI-compatible API on your machine — no token limit, no model weights, no GPU. It uses a fast, balanced reasoning model (not as powerful as full ZYR3).

# Download the compressed release (7 KB) and unzip
wget -q https://huggingface.co/zyr-AGENT/zyr3/resolve/main/zyr3-lite-1.0.0.zip
unzip zyr3-lite-1.0.0.zip
cd zyr3-lite

# Add your OpenRouter key, then serve on http://127.0.0.1:1234/v1
echo "sk-or-v1-..." > key.txt
python zyr3_lite.py

System requirements

Item	Minimum	Recommended
OS	Windows 10 (64-bit)	Windows 11
	macOS 11+	macOS 13+
	Linux x86_64/aarch64	—
CPU	1 core	2 cores
RAM	512 MB	1 GB
Disk	20 MB free	50 MB
GPU	none	none
Python	3.8+	3.11+

Dependencies: standard library only (no PyTorch, no GPU drivers). Token limit: none (unlimited). Upstream model: meta-llama/llama-3.3-70b-instruct via OpenRouter. See zyr3-lite/README.md for full docs.

Install ZYR3 (full, powerful, 5M token budget)

Full ZYR3 routes through the powerful ZYR3 multi-AI runtime (34 specialists) and enforces a fixed 5,000,000 token budget (cumulative, tracked per install).

# Download the compressed release (7 KB) and unzip
wget -q https://huggingface.co/zyr-AGENT/zyr3/resolve/main/zyr3-full-1.0.0.zip
unzip zyr3-full-1.0.0.zip
cd zyr3-full

# Serve on http://127.0.0.1:1234/v1
python zyr3_full.py

# Budget helpers
python zyr3_full.py --status        # show remaining budget
python zyr3_full.py --reset-budget  # refill to 5,000,000 tokens

System requirements

Item	Minimum	Recommended
OS	Windows 10 (64-bit)	Windows 11
	macOS 11+	macOS 13+
	Linux x86_64/aarch64	—
CPU	1 core	2 cores
RAM	1 GB	2 GB
Disk	30 MB free	60 MB
GPU	none	none
Python	3.8+	3.11+

Dependencies: standard library only (no PyTorch, no GPU drivers). Token limit: 5,000,000 tokens total; when exhausted the bridge replies 429 budget_exhausted. See zyr3-full/README.md for full docs.

Google Colab

Run ZYR3 in Google Colab — no GPU required. The model downloads in seconds and loads like any normal HF model.

Option A — Ready-to-run notebook

Download the notebook: zyr3_colab.ipynb
In Colab, click File → Upload notebook and select the downloaded file.
Run all cells (Runtime → Run all). It downloads the model, loads it, and generates code.

Option B — Download script

Download the wrapper files with the included zero-dependency script (uses only the Python standard library):

# Fetch the script straight from this repo
wget -q https://huggingface.co/zyr-AGENT/zyr3/resolve/main/download_zyr3.py

# Download the wrapper files into ./zyr3 (recommended)
python download_zyr3.py --dir zyr3

# Optional: also pull the legacy local weights
python download_zyr3.py --dir zyr3 --weights

Then load it from the downloaded folder:

from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("zyr3", trust_remote_code=True)
tokenizer = AutoTokenizer.from_pretrained("zyr3", trust_remote_code=True)

inputs = tokenizer("Write a Python web server", return_tensors="pt")
outputs = model.generate(**inputs, max_new_tokens=512)
print(tokenizer.decode(outputs[0]))

Inference is served by the ZYR3 API, so only an internet connection is needed — no GPU, no local weights.

LM Studio / OpenAI-compatible

ZYR3 is API-backed, so there is no GGUF file to download. Instead, use the included LM Studio bridge: a zero-dependency local server that speaks the exact same OpenAI-compatible API that LM Studio exposes on http://localhost:1234/v1. Point any OpenAI-compatible client or tool at it and it talks to ZYR3.

Quick start

# Fetch the bridge script from this repo
wget -q https://huggingface.co/zyr-AGENT/zyr3/resolve/main/zyr3_lmstudio.py

# Serve ZYR3 on http://127.0.0.1:1234/v1 (LM Studio's default endpoint)
python zyr3_lmstudio.py

Then configure any OpenAI-compatible client with:

base_url = "http://localhost:1234/v1"
api_key  = "lm-studio"     # any non-empty value works
model    = "zyr3"

Example with the OpenAI Python SDK:

from openai import OpenAI

client = OpenAI(base_url="http://localhost:1234/v1", api_key="lm-studio")
resp = client.chat.completions.create(
    model="zyr3",
    messages=[{"role": "user", "content": "Write a Python web server"}],
)
print(resp.choices[0].message.content)

Works with curl, the OpenAI SDK, and tools such as Continue, Cline, Aider, and LM Studio's own API surface. Endpoints: GET /v1/models, POST /v1/chat/completions (streaming supported), POST /v1/completions.

# Options
python zyr3_lmstudio.py --port 8080          # different port
python zyr3_lmstudio.py --host 0.0.0.0       # expose on your LAN
python zyr3_lmstudio.py --model zyr3         # model id exposed
python zyr3_lmstudio.py --no-ultra           # skip the ULTRA coding prompt
ZYR3_API_KEY=your-key python zyr3_lmstudio.py   # override the free key

Benchmarks

All benchmarks use real code execution in a sandbox. No LLM judge. No fabricated scores. Code runs → tests pass or fail.

Overall (22 challenges x 5 models = 110 executions)

Rank	Model	Passed	Score
#1	ZYR3	18/22	82%
#2	GLM 4 Flash	16/22	73%
#3	GLM 5.2	14/22	64%
#3	Mistral Large	14/22	64%
#3	Codestral	14/22	64%

SWE Pro Terminal (iterative debugging — hardest tier)

Challenge	ZYR3	GLM 5.2	GLM 4 Flash	Mistral	Codestral
REST API Server	✅ iter=2	❌	❌	❌	❌
Auth System	✅ iter=1	✅ iter=1	✅ iter=1	❌	❌
State Machine	✅ iter=3	✅ iter=3	✅ iter=3	❌	❌
File Watcher	✅ iter=2	✅ iter=1	✅ iter=1	✅ iter=1	✅ iter=1
Cache TTL	❌	❌	✅ iter=1	❌	❌
Observer	❌	❌	❌	❌	❌
Message Queue	❌	❌	❌	❌	❌

ZYR3 is the only model that passed the REST API Server challenge.

Package Contents

File	Description
`modeling_zyr3.py`	Transformers-compatible model wrapper (delegates to API)
`tokenization_zyr3.py`	Simple tokenizer
`config.json`	Model config
`zyr-22/`	Model folder — README, `model.ts` router, `model-registry.ts`, ZSMLLMCP, weights
`zyr-22/model.safetensors`	Placeholder weights (unused; inference is API-backed)
`zyr3-vscode-extension.vsix`	VSCode extension
`LICENSE`	Usage license (ZYR3 Free Use License 1.0)

License

ZYR3 Free Use License 1.0

ZYR3 is free to use for personal, educational, research, and commercial purposes.

The ZYR3 model and its weights remain proprietary and closed-source.

You may:

Use ZYR3 for personal and commercial applications.
Build applications and services using ZYR3.
Use ZYR3 internally within your organization.
Modify ZYR3 for your own private use.

You may not:

Modify, adapt, fine-tune, or create derivative works of ZYR3 for the purpose of redistributing or reselling them, whether for free or for a fee (personal modification for private use is allowed).
Sell or sublicense the ZYR3 model or its weights as a standalone product.
Redistribute or publicly mirror the model weights.
Upload or redistribute the model weights on another platform.
Claim ownership of the ZYR3 model or its weights.
Create a competing model distribution based primarily on ZYR3 weights.

See the LICENSE file for the complete terms.

Downloads last month: 368