CORU 15M V4 Prototype

A compact, experimental language model released by RRR PRO MEX.

CORU 15M V4 is a small, approximately 15-million-parameter, decoder-only Transformer prototype. It is shared publicly so developers, researchers, students, and AI enthusiasts can inspect the files, experiment with the model, run the demonstration, evaluate its behaviour, and build or test their own fine-tuning workflows.

This is an early-stage micro-scale model experiment—not a production-ready general-purpose LLM. Its purpose is to make compact-model experimentation accessible and to encourage learning, testing, improvement, and responsible reuse.

Prototype notice: Please evaluate the model for your own task before relying on it. Its outputs may be repetitive, incomplete, inaccurate, or unstable. The parameter count alone does not indicate its quality or suitability for a particular application.

Model at a glance

Property	Details
Model	CORU 15M V4 Prototype
Developer	RRR PRO MEX
Model scale	Approximately 15 million parameters
Architecture	Decoder-only Transformer with causal self-attention and SwiGLU feed-forward blocks
Framework	PyTorch
Tokenizer	SentencePiece
Vocabulary size	8,000 tokens (as specified in `config.json`)
Hidden dimension (`d_model`)	320
Transformer layers	10
Attention heads	8
Feed-forward hidden dimension	854
Context window in the supplied demo	256 tokens
Positional encoding	Disabled in this checkpoint configuration; no RoPE is used by the supplied inference implementation
Release status	Experimental prototype
License	Apache License 2.0 (subject to the rights and data-provenance note below)

The architecture values above are taken from the configuration and inference implementation included in this repository. The supplied demo uses a maximum context length of 256 tokens. This is a deliberately compact configuration and is not comparable to the context lengths of larger language models.

What is CORU?

CORU is an experimental compact-model project from RRR PRO MEX. This V4 release explores how a small neural language model can be packaged with its tokenizer, model configuration, weights, and a lightweight interactive inference application.

The project is shared as a practical starting point for experimentation. We welcome developers and researchers who want to study small Transformer models, test their own prompts, measure limitations, or explore ways to improve compact language models.

Why a 15M-parameter model?

Large language models can be capable, but they may require substantial memory, compute, serving infrastructure, and operating cost. Compact models explore a different design space: smaller checkpoints, simpler deployment experiments, and task-specific components that may run with fewer resources.

A 15M-parameter model is very small by modern language-model standards. That makes CORU useful as an educational and experimental artifact, but it also places real limits on the complexity and reliability of tasks it can perform. It should not be expected to match the reasoning, knowledge, instruction following, or language quality of much larger models.

What can you try with it?

Possible experiments include:

Running the supplied Gradio chat interface and observing how the model generates text.
Studying a compact decoder-only Transformer and its causal language-generation path.
Testing prompt formats, sampling settings, and short-context text generation.
Building a compatible training or fine-tuning pipeline using data that you have permission to use.
Comparing the model before and after fine-tuning on a narrow, well-defined task.
Exploring compact-model deployment on CPU or modest hardware, while measuring actual speed and memory use on your device.
Using it as a research component in a larger application, with external validation and fallback logic.

These are suggested experiments, not guaranteed capabilities or benchmark claims. Results depend on the task, data, hardware, and implementation.

Possible roles for micro-models in automation systems

A small model does not need to be a complete autonomous agent to be useful. In a carefully designed system, a compact model can be tested as one component in a larger, controlled workflow.

For example, after task-specific training and evaluation, a model in this size range might be explored for:

Intent classification and request routing — identify the broad type of a short incoming request and route it to the appropriate workflow.
Command or category classification — assign labels to short messages, records, or support requests.
Lightweight text processing — experiment with short completions, simple rewriting, tagging, or structured text extraction.
Local assistant components — test small language-generation features in an application where low resource use is important.
Automation pre-processing — classify or format an input before a deterministic program, API, or larger model performs the main operation.
Edge and offline research — measure whether a compact model can handle a narrowly scoped task on local hardware.

Example of a responsible automation design

A practical automation workflow can be structured as:

Input → preprocessing → CORU or another task model → output validation → permission/rule checks → approved tool or API action → audit log

The model should not be the only safety mechanism. Validate generated outputs, check permissions, log important actions, and require human approval for sensitive or irreversible operations. For complex multi-step planning, high-stakes decisions, or tasks requiring broad factual knowledge, use a stronger model or deterministic logic as appropriate.

Important: CORU 15M V4 is not currently a complete autonomous-agent framework. Scheduling, tools, memory, API integrations, access control, retries, monitoring, and action execution must be implemented by the application that uses the model.

Repository contents

File	Purpose
`coru_15m_final_v4.pt`	PyTorch model checkpoint / weights
`config.json`	Model name, parameter count, and architecture configuration
`coru_tokenizer.model`	SentencePiece tokenizer model
`coru_tokenizer.vocab`	Tokenizer vocabulary listing
`app.py`	Custom PyTorch inference implementation and Gradio demo interface
`requirements.txt`	Python dependency declaration for the Space (`sentencepiece`)

The checkpoint shown in the repository is approximately 69.7 MB. File sizes may change in future revisions.

Try the model

Option 1: Run the included demo locally

Clone the repository:

git clone https://huggingface.co/rrrpromex/CORU_15M_V4_prototype
cd CORU_15M_V4_prototype

Create and activate a virtual environment (recommended):

python -m venv .venv

On Windows PowerShell:

.venv\Scripts\Activate.ps1

On macOS or Linux:

source .venv/bin/activate

Install the dependencies required by the supplied local demo:

python -m pip install --upgrade pip
python -m pip install torch gradio "sentencepiece>=0.1.99"

Install a PyTorch build suitable for your operating system and hardware. CPU inference is supported by the supplied code, although generation speed depends on your hardware. A compatible CUDA-enabled PyTorch installation may be used when available.

Start the demo:

python app.py

Open the local Gradio URL printed in the terminal.

Option 2: Inspect or download individual files

Browse the files and revisions here:

CORU 15M V4 — Files and versions

The supplied app.py implements the model directly in PyTorch. This checkpoint is not presented as a plug-and-play Transformers AutoModel checkpoint. Applications using it should follow the architecture, tokenizer, and state-dictionary loading logic in the included implementation, or provide a compatible implementation of their own.

Fine-tuning and research use

You are welcome to experiment with fine-tuning or adapting CORU 15M V4 under the repository license, provided that you also have the necessary rights to the data and other materials you use.

A few important points before starting:

Preserve compatibility between the model architecture, checkpoint keys, tokenizer, and vocabulary. Changing one without updating the others can make the checkpoint incompatible.
Use the supplied SentencePiece tokenizer for experiments that continue from this checkpoint, unless you intentionally rebuild and retrain the model around a new tokenizer.
Prepare a clean training, validation, and test split. Avoid evaluating only on examples used for training.
Start with a narrow task and a small, well-curated dataset. Measure whether fine-tuning actually improves the target task.
Keep a copy of the original checkpoint so that experiments can be compared and reverted.
Publish your training configuration, data provenance, evaluation method, and limitations when sharing a fine-tuned version.

What is not included in this release

This repository contains the model checkpoint, configuration, tokenizer files, and inference/demo code. It does not currently provide a complete training pipeline, original training corpus, optimizer and scheduler configuration, training logs, or verified benchmark suite. Those details should not be assumed or reconstructed from the inference files alone.

Fine-tuning therefore requires you to supply or develop a compatible training script and an appropriately licensed dataset. This release does not promise that fine-tuning will produce a capable assistant; outcomes must be measured experimentally.

Limitations and responsible use

CORU 15M V4 is an experimental model with a small parameter budget and short context window. In particular:

It may generate incorrect, nonsensical, repetitive, or incomplete text.
It may not reliably follow complex instructions or multi-step reasoning tasks.
It does not contain a verified knowledge base and may hallucinate facts.
It should not be treated as a source of current information.
The supplied demo constructs each response from the current message using the User: ... / Assistant: prompt format. It does not feed previous turns back into the model as persistent conversational memory.
The presence of a chat interface does not mean that the model has reliable multi-turn conversation, tool use, planning, or autonomous-agent capabilities.
No performance, latency, energy, or quality benchmark is claimed in this model card.

Do not rely on this prototype by itself for medical, legal, financial, security-critical, or other high-impact decisions. Any real-world deployment should include task-specific testing, output validation, monitoring, and human oversight appropriate to the risk.

Evaluation status

This repository is published as a prototype for community experimentation. A comprehensive, independently reproducible evaluation report is not included at this time. Please do not interpret the parameter count, model-file size, or demo availability as evidence of benchmark performance.

Community evaluations are welcome. When reporting results, include the exact repository revision, hardware, software versions, dataset and split, evaluation procedure, and known limitations.

About RRR PRO MEX

RRR PRO MEX is an independent software and AI development brand focused on practical digital products, web applications, AI integrations, and experimental software projects.

The work spans digital tools and application development, with an interest in making useful technology more accessible and exploring lightweight, privacy-conscious, and resource-aware approaches where practical. CORU is one of the brand's experimental AI model projects.

Hugging Face: rrrpromex
Website and project updates: RRR PRO MEX
LinkedIn: RRR PRO MEX

License

The repository is intended to be released under the Apache License 2.0. You may use, reproduce, modify, distribute, and build upon the materials covered by that license, including for commercial purposes, subject to its terms and conditions. Please retain the required license and copyright notices and identify significant changes when redistributing modified files.

License identifier: apache-2.0
License text: Apache License, Version 2.0

License and data-provenance note: The Apache 2.0 declaration should only be used for files that RRR PRO MEX has the legal right to release under those terms. The license for model weights and code does not automatically relicense third-party training data. If any training data, tokenizer assets, code, or other included material has separate restrictions, those restrictions must be checked and disclosed. A public repository is not, by itself, proof that every upstream material is unrestricted.

Feedback and contributions

Testing, constructive feedback, bug reports, reproducibility notes, and well-documented research experiments are welcome through the Hugging Face repository discussions.

When sharing a derivative or fine-tuned model, please identify it as a derivative of CORU 15M V4, link to the original repository, document your changes, and provide your own evaluation results and data-license information.

CORU 15M V4 Prototype — an experimental compact-model release by RRR PRO MEX.

Downloads last month: 73