CORe Pico V1.5 (identityless)

CORe Pico V1.5 is a compact conversational language model from CORe Technologies. This is the identityless variant: the raw base model with no identity fine-tuning applied.

It has no name and no sense of self. Ask it who it is and it will improvise a persona, because nothing taught it otherwise. Because it was never fine-tuned, its fluency and knowledge are slightly better than the standard Pico V1.5, which traded a small amount of that for its identity.

Pick this variant if you want a blank slate to fine-tune your own identity or persona onto, or if you want the model's raw behavior with no built-in self-description.

Difference from standard Pico V1.5

What it does well

• Short factual answers. Direct questions get direct replies.
• Brief explanations and chat. Single-turn requests in plain language.
• A clean base for your own fine-tune. No baked-in identity to fight against.

What it is not

This is a 183M model. It will state wrong facts, lose the thread on long outputs, and improvise when it does not know something, including about itself. 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-identityless", trust_remote_code=True
)
model.eval()
tok = AutoTokenizer.from_pretrained("OpenCOReTechnologies/core-pico-v1-5-identityless")

def ask(question, max_new_tokens=200, temperature=0.8):
    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=50, do_sample=True)
    return tok.decode(out[0][enc["input_ids"].shape[1]:],
                      skip_special_tokens=True).strip()

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

Files

Chat template (important)

This model was trained on a specific chat format. If your app uses a different template (most default to Human:/AI: or ChatML), it 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 %}

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. Load the model, open the chat settings (the Prompt Template field under the model's settings).
2. Replace the Prompt Template with the Jinja block above.
3. Under Stop Strings, add <|endoftext|>.
4. Save and start a new chat.

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

Raw prompt (no template engine)

<|user|>
What is the capital of France?
<|assistant|>

Then stop on <|endoftext|>.

Details

Notes

• Best on single-turn prompts under a few hundred tokens.
• English only.
• No built-in identity; any self-description it gives is improvised.
• Registered as a custom core model via trust_remote_code, so it loads with plain transformers and nothing else.