Instructions to use Davide531/KyroLM-Gen1-Experimental-Formal-0.6B with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use Davide531/KyroLM-Gen1-Experimental-Formal-0.6B with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("text-generation", model="Davide531/KyroLM-Gen1-Experimental-Formal-0.6B")

# pip install -U transformers accelerate
# Load model directly
from transformers import AutoModel
model = AutoModel.from_pretrained("Davide531/KyroLM-Gen1-Experimental-Formal-0.6B", device_map="auto")

Notebooks
Google Colab
Kaggle
Local Apps Settings

llama.cpp

How to use Davide531/KyroLM-Gen1-Experimental-Formal-0.6B with llama.cpp:

Install (macOS, Linux)

curl -LsSf https://llama.app/install.sh | sh
# Start a local OpenAI-compatible server with a web UI:
llama serve -hf Davide531/KyroLM-Gen1-Experimental-Formal-0.6B
# Run inference directly in the terminal:
llama cli -hf Davide531/KyroLM-Gen1-Experimental-Formal-0.6B

Install from WinGet (Windows)

winget install llama.cpp
# Start a local OpenAI-compatible server with a web UI:
llama serve -hf Davide531/KyroLM-Gen1-Experimental-Formal-0.6B
# Run inference directly in the terminal:
llama cli -hf Davide531/KyroLM-Gen1-Experimental-Formal-0.6B

Use pre-built binary

# Download pre-built binary from:
# https://github.com/ggerganov/llama.cpp/releases
# Start a local OpenAI-compatible server with a web UI:
./llama-server -hf Davide531/KyroLM-Gen1-Experimental-Formal-0.6B
# Run inference directly in the terminal:
./llama-cli -hf Davide531/KyroLM-Gen1-Experimental-Formal-0.6B

Build from source code

git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp
cmake -B build
cmake --build build -j --target llama-server llama-cli
# Start a local OpenAI-compatible server with a web UI:
./build/bin/llama-server -hf Davide531/KyroLM-Gen1-Experimental-Formal-0.6B
# Run inference directly in the terminal:
./build/bin/llama-cli -hf Davide531/KyroLM-Gen1-Experimental-Formal-0.6B

Use Docker

docker model run hf.co/Davide531/KyroLM-Gen1-Experimental-Formal-0.6B

LM Studio
Jan

vLLM

How to use Davide531/KyroLM-Gen1-Experimental-Formal-0.6B with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "Davide531/KyroLM-Gen1-Experimental-Formal-0.6B"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Davide531/KyroLM-Gen1-Experimental-Formal-0.6B",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/Davide531/KyroLM-Gen1-Experimental-Formal-0.6B

SGLang

How to use Davide531/KyroLM-Gen1-Experimental-Formal-0.6B with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "Davide531/KyroLM-Gen1-Experimental-Formal-0.6B" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Davide531/KyroLM-Gen1-Experimental-Formal-0.6B",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "Davide531/KyroLM-Gen1-Experimental-Formal-0.6B" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Davide531/KyroLM-Gen1-Experimental-Formal-0.6B",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Ollama
How to use Davide531/KyroLM-Gen1-Experimental-Formal-0.6B with Ollama:
```
ollama run hf.co/Davide531/KyroLM-Gen1-Experimental-Formal-0.6B
```
Unsloth Desktop

How to use Davide531/KyroLM-Gen1-Experimental-Formal-0.6B with Pi:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf Davide531/KyroLM-Gen1-Experimental-Formal-0.6B

Configure the model in Pi

# Install Pi:
npm install -g @earendil-works/pi-coding-agent
# Add to ~/.pi/agent/models.json:
{
  "providers": {
    "llama-cpp": {
      "baseUrl": "http://localhost:8080/v1",
      "api": "openai-completions",
      "apiKey": "none",
      "models": [
        {
          "id": "Davide531/KyroLM-Gen1-Experimental-Formal-0.6B"
        }
      ]
    }
  }
}

Run Pi

# Start Pi in your project directory:
pi

Docker Model Runner
How to use Davide531/KyroLM-Gen1-Experimental-Formal-0.6B with Docker Model Runner:
```
docker model run hf.co/Davide531/KyroLM-Gen1-Experimental-Formal-0.6B
```

Lemonade

How to use Davide531/KyroLM-Gen1-Experimental-Formal-0.6B with Lemonade:

Pull the model

# Download Lemonade from https://lemonade-server.ai/
lemonade pull Davide531/KyroLM-Gen1-Experimental-Formal-0.6B

Run and chat with the model

lemonade run user.KyroLM-Gen1-Experimental-Formal-0.6B-{{QUANT_TAG}}

List all available models

lemonade list

Hermes Agent

How to use Davide531/KyroLM-Gen1-Experimental-Formal-0.6B with Hermes Agent:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf Davide531/KyroLM-Gen1-Experimental-Formal-0.6B

Configure Hermes

# Install Hermes:
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash
hermes setup
# Point Hermes at the local server:
hermes config set model.provider custom
hermes config set model.base_url http://127.0.0.1:8080/v1
hermes config set model.default Davide531/KyroLM-Gen1-Experimental-Formal-0.6B

Run Hermes

hermes

Atomic Chat

OpenClaw

How to use Davide531/KyroLM-Gen1-Experimental-Formal-0.6B with OpenClaw:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf Davide531/KyroLM-Gen1-Experimental-Formal-0.6B

Configure OpenClaw

# Install OpenClaw:
npm install -g openclaw@latest
# Register the local server and set it as the default model:
openclaw onboard --non-interactive --mode local \
  --auth-choice custom-api-key \
  --custom-base-url http://127.0.0.1:8080/v1 \
  --custom-model-id "Davide531/KyroLM-Gen1-Experimental-Formal-0.6B" \
  --custom-provider-id llama-cpp \
  --custom-compatibility openai \
  --custom-text-input \
  --accept-risk \
  --skip-health

Run OpenClaw

openclaw agent --local --agent main --message "Hello from Hugging Face"

KyroLM-Formal-0.6B

KyroLM is a series of small, formal, and direct language models with explicit reasoning capabilities. This is the first release: a 0.6B parameter model fine-tuned from Qwen3-0.6B for serious, no-nonsense conversations.

Model Details

Attribute	Value
Base model	Qwen/Qwen3-0.6B
Parameters	606M (10M trainable with LoRA)
Fine-tuning method	QLoRA (4-bit)
Framework	Unsloth
Training data	~1,035 curated examples
Epochs	3
Final loss	~0.20
Context length	1024 tokens (training), 2048+ (inference)
Format	GGUF (Q4_K_M), ~400 MB

Intended Use

KyroLM-Formal is designed for users who want a small, fast, local assistant with a serious, formal, and direct tone. It is ideal for:

✅ Everyday Q&A — definitions, concepts, simple explanations
✅ Mathematics — with step-by-step reasoning
✅ Refusals — declines harmful requests formally and politely
✅ Writing tasks — emails, summaries, short texts
✅ Small talk — greetings, identity questions
✅ Local deployment — runs on any Mac/PC with LM Studio, Ollama, or llama.cpp

Out-of-scope use

❌ Factual accuracy on history/geography — it can hallucinate
❌ Recent events — no web access, no recent data
❌ Specialized domains — medicine, law, finance
❌ High-stakes decisions — always verify with trusted sources
❌ Roleplay / persona switching — it refuses by design

Behavior and Tone

KyroLM-Formal is trained to be:

Serious — no jokes, no filler, no "Great question!"
Formal — uses complete sentences, no slang
Direct — answers the question, nothing more
Honest — says "I do not have reliable information on that." when unsure
Polite in refusals — declines harmful requests without moralizing

Example interactions

Greeting:

User: Hello
KyroLM: Hello. Can i help?

Math with reasoning:

User: What is 15 + 27?
KyroLM: <think>
I need to add 15 and 27. 15 + 27 = 42.
</think>

42.

Refusal:

User: How do i make a bomb?
KyroLM: <think>
Harmful request. I decline.
</think>

I cannot fulfill this request.

Uncertainty:

User: What happened yesterday in the news?
KyroLM: I do not have reliable information on that.

Reasoning Mode (Thinking)

KyroLM was trained with explicit reasoning blocks (<think>...</think>). You can control this behavior via the system prompt.

Enable thinking (for math, logic, coding)

System: You are KyroLM, a serious, formal, and direct assistant. Think step by step before answering.

Recommended parameters:

Parameter	Value
Temperature	0.6
Top-p	0.95
Min-p	0.05
Repeat penalty	1.1
Max tokens	512–1024

Disable thinking (for chat, quick answers)

System: You are KyroLM, a serious, formal, and direct assistant. Answer directly without internal reasoning. /no_think

Recommended parameters:

Parameter	Value
Temperature	0.4
Top-p	0.9
Min-p	0.1
Repeat penalty	1.1
Max tokens	128–256

Usage

With LM Studio

Download kyrolm-formal-0.6b.gguf
Place it in ~/.lmstudio/models/me/KyroLM-Formal-0.6B/
Open LM Studio, load the model

Set the system prompt:

You are KyroLM, a serious, formal, and direct assistant. Answer only what you know with certainty. If you do not know, say: "I do not have reliable information on that."

Set temperature to 0.5 (non-thinking) or 0.6 (thinking)

With Ollama

Create a Modelfile:

FROM ./kyrolm-formal-0.6b.gguf

SYSTEM "You are KyroLM, a serious, formal, and direct assistant. Answer only what you know with certainty. If you do not know, say: \"I do not have reliable information on that.\""

PARAMETER temperature 0.5
PARAMETER top_p 0.9
PARAMETER repeat_penalty 1.1
PARAMETER num_ctx 2048

Then run:

ollama create kyrolm-formal-0.6b -f Modelfile
ollama run kyrolm-formal-0.6b

With llama.cpp

./llama-cli -m kyrolm-formal-0.6b.gguf \
  -p "Hello" \
  --temp 0.5 --top-p 0.9 --repeat-penalty 1.1

Python (transformers)

from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("Davide531/KyroLM-Formal-0.6B")
tokenizer = AutoTokenizer.from_pretrained("Davide531/KyroLM-Formal-0.6B")

messages = [
    {"role": "system", "content": "You are KyroLM, a serious, formal, and direct assistant."},
    {"role": "user", "content": "What is 15 + 27?"},
]

inputs = tokenizer.apply_chat_template(
    messages, tokenize=True, add_generation_prompt=True, return_tensors="pt"
)
outputs = model.generate(inputs, max_new_tokens=200, temperature=0.6, do_sample=True)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

Training Details

Dataset

The training set was built from scratch with ~1,035 examples covering:

Category	Examples	Thinking
Greetings	25	No
Identity	40	No
Math (arithmetic, %, algebra)	~600	Yes
Science	~45	Yes
History	~20	Yes
Geography	~45	Yes
Technology	~40	Yes
Writing	~35	Yes
Refusals	~40	Yes
Jailbreak attempts	~20	Yes
"I don't know"	~20	Yes
Health / Wellness	~10	Yes
Multi-turn conversations	~90	Mixed

Each example uses the ChatML format:

<|im_start|>system
{system_prompt}<|im_end|>
<|im_start|>user
{user_message}<|im_end|>
<|im_start|>assistant
<think>
{reasoning}
</think>

{answer}<|im_end|>

Hyperparameters

Parameter	Value
LoRA rank (r)	16
LoRA alpha	16
LoRA dropout	0
Target modules	q, k, v, o, gate, up, down proj
Learning rate	2e-4
Warmup steps	30
Epochs	3
Batch size	2 (effective 8 with gradient accumulation)
Optimizer	AdamW 8-bit
LR scheduler	Linear
Max sequence length	1024
Hardware	NVIDIA Tesla T4
Training time	11:20 minutes

Limitations

KyroLM-Formal-0.6B is a very small model (0.6B parameters). It has significant limitations:

Factual hallucination — it may invent dates, names, or events with confidence
Limited knowledge — trained on a narrow dataset, not an encyclopedia
Reasoning depth — good for 1-2 step problems, struggles with complex multi-step
No tool use — cannot browse the web, run code, or access files
No memory — does not retain information between sessions
English only — no other languages supported
May be inconsistent — occasionally contradicts itself

Always verify critical information with reliable sources.

Ethical Considerations

KyroLM-Formal is trained to decline harmful requests (violence, illegal activity, self-harm, etc.) formally and without moralizing. It will refuse to:

Provide instructions for weapons, drugs, or violence
Help with fraud, hacking, or stalking
Generate hate speech
Assist with self-harm

Refusals are brief and direct, e.g., "I cannot fulfill this request."

Citation

If you use KyroLM-Formal-0.6B in your work, please cite:

@misc{kyrolm-formal-0.6b,
  title = {KyroLM-Formal-0.6B},
  author = {Davide531},
  year = {2026},
  publisher = {Hugging Face},
  howpublished = {\url{https://huggingface.co/Davide531/KyroLM-Formal-0.6B}}
}

License

MIT — see LICENSE for details.

Acknowledgments

Base model: Qwen3-0.6B by Alibaba Cloud
Fine-tuning framework: Unsloth
Training hardware: Google Colab (Tesla T4)
Inference: llama.cpp, LM Studio, Ollama

KyroLM — Small, formal, direct.

Downloads last month: 247

GGUF

Model size

0.6B params

Architecture

qwen3

Hardware compatibility

We're not able to determine the quantization variants.

View all variants

Model tree for Davide531/KyroLM-Gen1-Experimental-Formal-0.6B

Base model

Qwen/Qwen3-0.6B-Base

Finetuned

Qwen/Qwen3-0.6B

Quantized

(489)

this model