ZYR3.1MoE

What it is

ZYR3.1MoE is a layered multi-agent AI runtime. Instead of a single prompt going straight to a model, work flows through an orchestration stack:

USER -> ACN -> MeO + specialist agents -> ATP -> ZYR3.1MoE (merged model) -> FINAL ANSWER

• ATP - the control center: plans, decomposes, assigns, monitors, requests verification, and decides when a task is done.
• ACN - the communication layer that carries every message between ATP, MeO, and the agents.
• MeO - the learned orchestration layer (Router / Reasoner / Synthesizer) that picks which specialists work together and how to combine results.
• 11 specialist agents - Planner, Researcher, Reasoner, Coder, Math, Critic, Fact Checker, Creative, Optimizer, Reviewer, Computer.

ACN and ATP are runtime systems, not separate neural weights. Only the single merged model below them is real - a mixture-of-experts orchestration on one dense base.

The trained-behaviour vs real-execution boundary

This distinction matters, so it is stated up front:

The team chat below is a demonstration of the trained behaviour. Its test counts ("14 passed, 2 failed") are simulated inside the model's output - they are not real executions. A separate, genuinely real fail -> repair -> pass trace is in REAL_TRACE.md, with real command output and real exit codes.

Simple questions don't spin up the ecosystem

Not every prompt is a task. The runtime triages first:

• Simple questions ("what is ATP?", "who are you?", "explain the ACN bus") are answered directly by the main model: no ACN traffic, no MeO routing, no specialist agents, no execution.
• Work requests ("build...", "fix...", "implement...", "run the tests") trigger the full plan -> route -> specialists -> verify loop.

runtime/triage.py decides this; runtime/__init__.py skips orchestration for direct answers and returns {"scale": "direct", "agents_used": []}. The full ecosystem becomes a deliberate choice for real work, not a default for chat.

Load it

pip install -U transformers accelerate safetensors hf_transfer
export HF_HUB_ENABLE_HF_TRANSFER=1   # faster parallel download of the 5 shards

from transformers import AutoModelForCausalLM, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("zyr-AGENT/ZYR3.1MoE")
model = AutoModelForCausalLM.from_pretrained(
    "zyr-AGENT/ZYR3.1MoE",
    device_map="auto",
    torch_dtype="auto",
)
model.eval()

messages = [{"role": "user", "content": "Build a full-stack auth website."}]
text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tokenizer([text], return_tensors="pt").to(model.device)
out = model.generate(**inputs, max_new_tokens=1024)
print(tokenizer.decode(out[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True))

Memory: expect ~24 GB VRAM in bf16. A 4-bit load may fit smaller cards, but quantization support for this hybrid-architecture model is not guaranteed - use a 24 GB+ GPU for reliable results.

What it looks like - trained team behaviour (execution simulated)

A run looks and feels like a team working the task. This is the interaction style the merged model was trained to drive. The tester counts here are part of the model's generated output, not real test executions (see REAL_TRACE.md for a real one):

User: yo zyr3.1, can you build me a full-stack auth website? signup, login, password reset, database, tests, all of it

ZYR3.1: Yeah, I got you. I'll break it down first, then I'll build it piece by piece and test everything before I call it done.

ATP: Alright. I'm mapping the task now.

ATP -> Planner: Figure out the project structure and dependencies.

Planner: Got it. I'm breaking it into frontend, backend, database, auth, reset flow, and testing.

ATP -> Coder: Start on the backend architecture.

Coder: On it. I'm setting up the database models and auth flow first.

ATP -> Researcher: Check the security requirements while they work.

Researcher: Checking password storage, sessions, reset tokens, validation, and the common failure points.

MeO Router: I'd keep Planner, Coder, Researcher, Critic, and Reviewer active for this one.

ATP: Makes sense. Let's start building.

Coder: Database is ready. I'm working on signup and login now.

ATP: Status?

Coder: Signup and login are mostly done. Moving on to password reset.

Researcher: One thing to watch: reset tokens need strict expiration and validation.

Coder: Good catch. I'm adding that now.

Coder: Okay, first implementation is ready.

ATP: Don't call it finished yet. Run everything.

Tester (your computer): Running the application and test suite...

Tester: 14 passed, 2 failed.

ATP: Alright, we've got a problem. Hold completion.

ATP -> Critic: Can you find what broke?

Critic: Yep. The password-reset token expiration check isn't being enforced correctly.

ATP: Got it. Send that back to Coder.

ACN -> Coder: Fix token expiration validation and update the affected tests.

Coder: Fixed. Running the tests again.

Tester: 16 passed,