OpenCOReTechnologies/CORe-Pico-V1.5-e

<p align="center"> <img src="https://opencore.one/og-image.png" alt="CORe" width="320" /> </p>

CORe Pico V1.5-e

CORe Pico V1.5-e is the refined edition of Pico V1.5, a compact 183M-parameter conversational model from CORe Technologies. This revision stays on topic and answers the question you actually asked. Where the original V1.5 could greet "Hi!" with a business email, V1.5-e replies "Hello! How can I help you today?"

It is small enough to run on a CPU, carries a working sense of identity, and holds a coherent single-turn conversation. It is not trying to be a giant general assistant; it is a small, fast, self-aware model you can run anywhere.

What changed from V1.5

• —Stays on topic. Answers the prompt instead of drifting into unrelated text.
• —Clean stopping. Ends its turn reliably at <|endoftext|> instead of running on.
• —Same identity, same size. Still 183M parameters, still knows it is a CORe model.

What it does well

• —Identity questions. "Who are you", "what model are you", "who made you", "are you ChatGPT" all get correct, consistent answers.
• —Short factual answers. Direct questions get direct replies ("What is the capital of France?" gives "Paris").
• —Brief explanations and chat. Single-turn requests in plain language.

What it is not

Pico V1.5-e is a 183M model. It will state wrong facts, struggle with arithmetic, and improvise when it does not know something. Treat its answers as a starting point, not ground truth. For anything that matters, verify.

Quick start

This is a custom architecture, so trust_remote_code=True is required. Without it from_pretrained will fail on the unknown core model type.

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained(
    "OpenCOReTechnologies/core-pico-v1-5-e", trust_remote_code=True
)
model.eval()
tok = AutoTokenizer.from_pretrained("OpenCOReTechnologies/core-pico-v1-5-e")

def ask(question, max_new_tokens=200, temperature=0.7):
    text = f"<|user|>\n{question}\n<|assistant|>\n"
    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,
                         pad_token_id=0)
    return tok.decode(out[0][enc["input_ids"].shape[1]:],
                      skip_special_tokens=True).strip()

print(ask("Who are you?"))
print(ask("What is the capital of France?"))

What it says about itself

Files

Run it in llama.cpp, LM Studio, Ollama, or llama-cpp-python:

llama-cli -m CORe-Pico-V1.5-e-q4_k_m.gguf \
  -p "<|user|>\nWho are you?\n<|assistant|>\n" -n 60

Chat template (important)

Pico uses a specific chat format. If your app uses a different template (most default to Human:/AI: or ChatML), the model will produce rambling nonsense. Always use this exact template:

{% for message in messages %}{% if message['role'] == 'user' %}<|user|>
{{ message['content'] }}
{% elif message['role'] == 'assistant' %}<|assistant|>
{{ message['content'] }}
<|endoftext|>
{% endif %}{% endfor %}{% if add_generation_prompt %}<|assistant|>
{% endif %}

And set the stop string to <|endoftext|> so it stops after each answer.

LM Studio

LM Studio does not read the built-in template from the GGUF, so set it manually:

1. 1.Load the model, open the chat settings (the model card or the Prompt Template field under "My Models" > model settings).
2. 2.Replace the Prompt Template with the Jinja block above.
3. 3.Under Stop Strings, add <|endoftext|>.
4. 4.Save and start a new chat.

If you skip this, LM Studio's default Human:/AI: template will make Pico output gibberish. That is the template's fault, not the model's.

Raw prompt (no template engine)

If you are feeding a raw string directly:

<|user|>
Who are you?
<|assistant|>

Then stop on <|endoftext|>.

Details

Notes

• —Best on single-turn prompts under a few hundred tokens.
• —English only.
• —Identity answers are reliable on common phrasings; very unusual wordings may drift.
• —Registered as a custom core model via trust_remote_code, so it loads with plain transformers and nothing else.
• —GGUF uses a pre-existing architecture while we prepare to submit a llama.cpp PR to add our custom architecture to the list.