Eunoia-4b-mini
A compact reasoning model with an external control layer that keeps goals, constraints and structure intact across long multi-step tasks — and recovers when a step fails instead of looping on it.
- Parameters
- ~4B
- Base model
- Qwen3-4B-Instruct-2507
- Architecture
- Transformer + external controller
- Licence
- Apache 2.0
- Language
- English
- Availability
- Available now
Instruction fades as decoding continues.
Ask for exactly seven steps, no bullets, future tense, calm tone. Somewhere past the third step the model stops holding all four at once. By the sixth it is producing good prose that answers a slightly different question than the one asked.
This is not a knowledge failure and more parameters do not reliably fix it. The instruction, the constraints and the content all enter as one undifferentiated stream, and the further decoding goes, the less the instruction weighs.
Anyone who has shipped an agent has watched this happen and has worked around it with retries, chunking and prompt repetition.
Compress behaviour, not intelligence.
The layer does not try to make a model know more. It makes a model keep doing what it was told, for as long as the task runs. Reasoning structure is low-entropy and survives compression; fluency is not what we are protecting.
It is not a smaller brain. It is a more disciplined one.
Where this does not help
- Encyclopedic knowledge. The layer adds none.
- Multilingual coverage. Out of scope.
- Creative prose. If anything, discipline works against it.
- Short outputs. There is nothing to drift from in three sentences.
What we publish, and what we keep.
Released
- The harness and its full source
- Configurations and routing policy shell
- The evaluation benchmark
- The reference build on Hugging Face
Retained
- CRSTO, our behaviour-aware compression research
- Adapter evolution logic
- Routing heuristic tuning
- Control-loop heuristics
Open shell, private recipe. You can run it, change it, and put your own model under it without our internals.
How the control loop works.
A standard model generates in one pass and hopes the instruction survives to the end. Eunoia separates what to do from how to write it, and runs the deciding part as an explicit loop.
- 01
Goal formation
The instruction is read as a goal and decomposed into sub-goals arranged in a hierarchy rather than a flat list.
- 02
Step execution
The base model produces candidate output for whichever goal is currently active.
- 03
Semantic evaluation
That output is checked against the goal it was meant to satisfy — not whether it reads well, whether it did the thing.
- 04
Execution gating
On the result of that check the system advances, retries, or abandons the current goal.
- 05
Adaptive goal mutation
When a goal keeps failing, the goal itself is restructured — split, simplified or reframed — instead of the same prompt being run again.
The last step is the one that matters most. Repeated failure on the same framing usually means the framing is wrong, and regenerating against it is how agents end up in loops.
What that changes.
| Standard instruction-tuned model | Eunoia-4B-Mini | |
|---|---|---|
| Reasoning flow | Single-pass generation | Multi-step controlled loop |
| Failure handling | Regenerate and hope | Evaluate, retry, restructure |
| Goal awareness | Implicit in the prompt | Explicit goal hierarchy |
| Long-horizon stability | Degrades with length | Held by the control logic |
| Agent readiness | Requires scaffolding | Native |
It does not replace the transformer. It orchestrates one.
Get started.
Works with a standard text-generation pipeline. No special token format and no custom runtime.
from transformers import AutoTokenizer, AutoModelForCausalLM
tokenizer = AutoTokenizer.from_pretrained("shvgroups/Eunoia-4B-mini")
model = AutoModelForCausalLM.from_pretrained("shvgroups/Eunoia-4B-mini")
prompt = "Explain photosynthesis step by step."
inputs = tokenizer(prompt, return_tensors="pt")
outputs = model.generate(**inputs, max_new_tokens=256)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))Run the model
The published build, ready to load. Apache 2.0, fine-tuned from Qwen3-4B-Instruct-2507.
Take the controller
Goal tree, evaluator, gate and mutation engine sit outside the model — inspectable, replaceable, and portable to another base.
What it is for.
- Multi-step reasoning where a later step depends on an earlier one holding.
- Long-form explanation and structured problem solving.
- Planner–executor and tool-augmented agent architectures.
- Research on retry, recovery and adaptive reasoning loops.
Not designed for
- Safety-critical decision making.
- Medical, legal or financial advice.
- Fully autonomous control of real-world systems.
- Anything requiring formal guarantees or verification.
- Correctness. The control system improves structure, not truth — pair it with external verification where being right matters.
How this gets graded.
Standard benchmarks measure what a model knows. None of them measure whether it is still following its instruction six hundred tokens later, so we publish against metrics that do. Formal results are not out yet.
Benchmark figures are published when measured, not before.
Attribution and licence.
Fine-tuned from Qwen3-4B-Instruct-2507. We did not train that base and do not present it as ours — the controller is the contribution, and it is built to move to another base.
Released under Apache 2.0. No private or user data was used.
@misc{eunoia4bmini2025,
title = {Eunoia-4B-Mini: Goal-Driven Long-Horizon Reasoning},
author = {SHV Groups},
year = {2025},
url = {https://huggingface.co/shvgroups/Eunoia-4B-mini}
}- Developed by
- SHV Groups Pvt. Ltd.
- Base model
- Qwen/Qwen3-4B-Instruct-2507
- Licence
- Apache 2.0
- Paper
- Coming soon