OpenCOReTechnologies/CORe-Predetermined-v1

CORe Predetermined V1

CORe Predetermined V1 is a tiny (30M-parameter) decoder-only language model from CORe Technologies, built for one job: predetermined outcomes without brittle exact-match rules.

Traditional FAQ / canned-response software matches user input against thousands of stored question strings, and breaks the moment someone types who's patricia instead of who is patricia. CORe Predetermined takes a different approach: you fine-tune it on your question/answer pairs once, and the model generalizes across phrasing, so any reasonable rewording of a covered question returns your predetermined answer.

• Base model is already filled with a few preview Q&As (AI-fundamentals concepts) so you can test the behavior immediately, ask about them in any phrasing you like.
• Fine-tune it on your own Q&A set to replace or extend the predetermined knowledge. A few dozen pairs is enough.
• Runs anywhere: 120MB, CPU-friendly, no GPU required for inference.

Quick start

Note: this is a custom architecture, so trust_remote_code=True is required — without it from_pretrained will raise an error about the unknown core model type.

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained(
    "OpenCOReTechnologies/CORe-Predetermined-v1", trust_remote_code=True
)
model.eval()
tok = AutoTokenizer.from_pretrained("OpenCOReTechnologies/CORe-Predetermined-v1")

def ask(question, max_new_tokens=120, temperature=0.3):
    text = tok.apply_chat_template(
        [{"role": "user", "content": question}],
        add_generation_prompt=True, tokenize=False,
    )
    enc = tok(text, add_special_tokens=False, return_tensors="pt")
    out = model.generate(**enc, max_new_tokens=max_new_tokens,
                         temperature=temperature, top_k=40, do_sample=True)
    return tok.decode(out[0][enc["input_ids"].shape[1]:],
                      skip_special_tokens=True).strip()

print(ask("what's an intelligent agent?"))   # phrasing is flexible

Try the built-in preview questions

The base model ships with a small set of memorized AI-concept answers. Ask them in your own words, the point is that exact phrasing doesn't matter:

Try asking	Observed base-model behavior
"What is an intelligent agent?"	Strongly memorized, responds with the full structured breakdown ("Let's break down what an intelligent agent is… perception, reasoning, action…") across phrasings
"Explain machine learning in simple terms"	Strongly memorized, returns the training answer's structure and opening
"What is artificial intelligence?"	Memorized concepts (learning, problem-solving, AGI) with some paraphrase drift
"What is a neural network?"	Coherent memorized definition, some drift
"What is deep learning?"	Coherent short definition, some drift

The strongly-memorized rows demonstrate the core behavior: one training example, robust retrieval across rephrasings. Fine-tuning on your own pairs moves your content into that strongly-memorized regime.

Fine-tuning your own predetermined answers

Prepare a text file of Q&A pairs in the chat format:

<|user|>
How do I reset my password?
<|assistant|>
Go to Settings → Account → Reset Password. The reset link expires in 15 minutes.
<|endoftext|>

Fine-tune with any standard causal-LM loop (the model is a plain PreTrainedModel, so Trainer, accelerate, or a hand-rolled loop all work). At 30M parameters, a full fine-tune runs on a laptop CPU in minutes to hours depending on dataset size. Low learning rates (1e-5 to 5e-5) with a few epochs over your pairs is usually enough; the model is small enough that it will memorize your set quickly while keeping phrasing robustness.

Tips:

• 20–200 pairs per topic cluster works well; you do not need thousands of exact-string variants.
• Keep answers canonical, the model will reproduce the content of your answer even when the wording of the question changes.
• Mix in a small amount of generic text if you want to preserve conversational fluency outside your covered topics.

Available variants

Pick the file that fits your deployment. All produce identical answers; smaller = faster CPU inference.

File	Size	Use case
model.safetensors	129 MB	fp32 reference; fine-tuning from this checkpoint
bf16/model.safetensors	65 MB	bf16 weights for modern GPUs
gguf/core-predetermined-v1-f16.gguf	58 MB	llama.cpp, full precision
gguf/core-predetermined-v1-q8_0.gguf	31 MB	llama.cpp, 8-bit, near-lossless
gguf/core-predetermined-v1-q4_k_m.gguf	20 MB	llama.cpp, 4-bit, smaller than most game textures; runs on anything

GGUF usage (llama.cpp, llama-cpp-python, LM Studio, Ollama, etc.):

llama-completion -m core-predetermined-v1-q4_k_m.gguf \
  -p "<|user|>\nwhat even is ai\n<|assistant|>\n" -n 120

Model details

Architecture	COReForCausalLM (custom CORe decoder-only transformer)
Parameters	29.7M
Layers / heads / width	8 / 8 / 512
Context length	512 tokens
Tokenizer	8,192-token BPE, chat-formatted (<|user|>, <|assistant|>)
Training data	~12.7M tokens of chat-formatted AI-education text
License	Apache-2.0

Limitations

• This is a 30M-parameter model. It is not a general-purpose assistant and will not compete with large models on open-ended tasks; that is not what it's for. Treat it as a flexible lookup layer over your predetermined content.
• Outside its fine-tuned coverage it will improvise, sometimes incorrectly. For production use, gate responses on confidence or restrict usage to covered topics.
• Training data was English-only; other languages are unsupported.

_{The architecture is registered as a first-class custom COReForCausalLM model (model_type: core) via trust_remote_code, no external framework code required beyond transformers itself.}