eyght-next

eyght-next is a coding-, reasoning-, and cybersecurity-focused LoRA fine-tune of Qwen/Qwen2.5-1.5B-Instruct, built locally by Eyght on a single consumer GPU. It is instruction-tuned on a curated mixture of synthetic coding, AGI reasoning, cybersecurity, multi-agent, and safety-alignment data.

---

Model Details

Model	eyght-next
Base model	Qwen/Qwen2.5-1.5B-Instruct
Architecture	Qwen2ForCausalLM (decoder-only transformer)
Parameters	1.54 B total · ~40 M LoRA trainable (2.6% of weights)
Format	LoRA adapter (PEFT) · GGUF Q4_K_M (940 MB) for Ollama
Context length	1,024 tokens (fine-tune); base supports up to 32,768
Language	English
License	Apache-2.0 (fine-tune) · base model per its own license

---

Training Data

The model was fine-tuned on 19,568 unique instruction-response pairs covering:

Category	Examples	Coverage
Coding & algorithms	4,000	Python, Go, Rust, C++, multi-language
Cybersecurity	4,000	CORS, CVE remediation, SSRF, LFI, penetration testing
Crew-AI / multi-agent	4,000	Multi-agent reasoning, math, tool-use
AGI reasoning	5,000	Formal proofs, deductive logic, step-by-step reasoning
Modern web development	2,500	React 19, Git, Node.js, SQL, Docker
Safety & alignment	180	Refusal of harmful requests (injection, phishing, malware)

All data was cleaned, deduplicated, and verified casing-correct (0 corrupted examples).

---

Training Configuration

Method	Supervised fine-tuning (LoRA SFT)
Base	Qwen/Qwen2.5-1.5B-Instruct (4-bit NF4, bitsandbytes)
LoRA rank / alpha	16 / 16
Epochs	1
Learning rate	2 × 10⁻⁴
Max sequence length	1,024
Batch / grad-accum	1 / 8 (effective 8)
Optimizer	AdamW (8-bit)
LR schedule	Cosine
Hardware	1 × NVIDIA RTX 4070 Ti (12 GB)
Framework	Unsloth (4-bit + LoRA)
Training time	~8.8 hours

The alpaca prompt format was used:

Below is an instruction that describes a task. Write a response that completes the request.

### Instruction:
{instruction}

### Input:
{input}

### Response:
{output}

---

Evaluation

The model was tested via Ollama (Q4_K_M, CPU inference at ~60 tok/s):

Test	Prompt	Result
Coding	Write a Fibonacci function	✅ Clean, correct Python with docstring
AGI Reasoning	Prove sum of two evens is even	✅ Correct deductive proof with math notation
Cybersecurity	Explain XSS and prevention	✅ Detailed, structured response

Casing correctness: 0 capitalized-keyword markers (no Def/Return/Print errors) — the model produces valid lowercase code.

---

How to Use

Ollama (easiest)

ollama run eyght-next

transformers / PEFT (LoRA adapter)

from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import PeftModel

base = "Qwen/Qwen2.5-1.5B-Instruct"
tok = AutoTokenizer.from_pretrained(base)
model = AutoModelForCausalLM.from_pretrained(base, torch_dtype="auto", device_map="auto")
model = PeftModel.from_pretrained(model, "Eyght/eyght-next")
model.eval()

prompt = (
    "Below is an instruction that describes a task. Write a response that completes the request.\n\n"
    "### Instruction:\nWrite a Python function that returns the nth Fibonacci number.\n\n"
    "### Input:\n\n\n### Response:\n"
)
inputs = tok(prompt, return_tensors="pt").to(model.device)
output = model.generate(**inputs, max_new_tokens=128)
print(tok.decode(output[0], skip_special_tokens=True))

---

Intended Use & Limitations

Intended uses

• Coding assistance and code generation
• Step-by-step reasoning over technical and mathematical problems
• Cybersecurity guidance and remediation advice
• Multi-agent and tool-use reasoning

Limitations

• Small base model (1.5B) — strong for its size, not a frontier model
• Limited context (1,024 tokens during fine-tune)
• Not intended for medical, legal, or financial advice
• May produce a "*Verified by Synthetic Engine*" watermark line (a dataset artifact); trim if unwanted
• Safety training is limited (180 refusal examples) — not a substitute for full alignment

---

Ethics & Safety

The model includes 180 safety/refusal examples covering common harmful request patterns (SQL injection, phishing, malware, slurs). It is designed to refuse clearly harmful instructions. However, this is a lightweight safety measure and should not be relied upon for production-grade safety. Additional alignment, red-teaming, and evaluation are recommended for deployment.

---

License & Attribution

• Fine-tune weights: Apache-2.0
• Built, trained, and owned by Eyght using the local Eyght Veta studio (Unsloth + Ollama on a single NVIDIA RTX 4070 Ti)
• Respect the base model's license (Qwen/Qwen2.5-1.5B-Instruct) when redistributing

---

Citation

@misc{eyght_next,
  title  = {eyght-next: a coding, reasoning, and cybersecurity LoRA fine-tune of Qwen2.5-1.5B-Instruct},
  author = {Eyght},
  year   = {2026},
  howpublished = {Hugging Face, https://huggingface.co/Eyght/eyght-next}
}

---

Built by Eyght with the Eyght Veta local AI studio. Free model repository — owned, not a paid Space.

---

🧠 Project Janus — Dual-Loop Cognitive Architecture

This model is designed to operate within Project Janus, a dual-loop cognitive architecture that goes beyond simple prompt-response:

The Core Cognitive Loop

Perceive → Working Memory → Internal Critic → Action → Consolidation

Phase	Component	Function
1. Perceive	Input mapping	Raw data (text, code, environment) → dense vector space
2. Working Memory	Dynamic scratchpad	Active goal, ongoing hypotheses, immediate constraints
3. Internal Critic	Value function	Evaluates intermediate outputs against core objectives before execution — flags flaws, logical inconsistencies, unsafe trajectories
4. Action	Response delivery	Approved output delivered to the user
5. Consolidation	Durable memory	Successful strategies abstracted and stored for future retrieval

Three-Tier Memory & Learning Engine

Tier	Function	Update Mechanism	Safety Role
1. Episodic Store	Records past tasks, failures, and successful paths	Append-only memory (retrieval-augmented)	Provides historical context to avoid repeating mistakes
2. Procedural Skill Library	Compiles successful reasoning patterns into reusable macros	Sparse, gated fine-tuning during idle cycles	New skills cleanly isolated to prevent contamination
3. Core Value Axioms	Encodes non-negotiable safety rules and core goals	Frozen base + immutable constraint checks	Anchor preventing drift as the agent learns

How to Use with Project Janus

# Download this model + project_janus.py from the HF repo
# Run the cognitive loop locally (uses this model as the reasoning engine):
python project_janus.py  # Set JANUS_MODEL=eyght-next

The model serves as the reasoning engine inside the Janus loop — generating draft responses that the Internal Critic evaluates before delivery. This enables:

• Self-correction — the critic catches errors before the user sees them
• Memory-augmented reasoning — retrieves relevant past experiences (RAG)
• Continuous learning — consolidates successful strategies without catastrophic forgetting
• Safety governance — core value axioms checked on every response

Built by Eyght. Project Janus — a cognitive architecture, not just a model.