Instructions to use pocketsflow/penny-1 with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use pocketsflow/penny-1 with Transformers:

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

pipe = pipeline("text-generation", model="pocketsflow/penny-1")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# pip install -U transformers accelerate
# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("pocketsflow/penny-1")
model = AutoModelForCausalLM.from_pretrained("pocketsflow/penny-1", device_map="auto")
messages = [
    {"role": "user", "content": "Who are you?"},
]
inputs = tokenizer.apply_chat_template(
	messages,
	add_generation_prompt=True,
	tokenize=True,
	return_dict=True,
	return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=256)
print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

llama.cpp

How to use pocketsflow/penny-1 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 pocketsflow/penny-1:Q4_K_M
# Run inference directly in the terminal:
llama cli -hf pocketsflow/penny-1:Q4_K_M

Install from WinGet (Windows)

winget install llama.cpp
# Start a local OpenAI-compatible server with a web UI:
llama serve -hf pocketsflow/penny-1:Q4_K_M
# Run inference directly in the terminal:
llama cli -hf pocketsflow/penny-1:Q4_K_M

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 pocketsflow/penny-1:Q4_K_M
# Run inference directly in the terminal:
./llama-cli -hf pocketsflow/penny-1:Q4_K_M

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 pocketsflow/penny-1:Q4_K_M
# Run inference directly in the terminal:
./build/bin/llama-cli -hf pocketsflow/penny-1:Q4_K_M

Use Docker

docker model run hf.co/pocketsflow/penny-1:Q4_K_M

LM Studio
Jan

vLLM

How to use pocketsflow/penny-1 with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/pocketsflow/penny-1:Q4_K_M

SGLang

How to use pocketsflow/penny-1 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 "pocketsflow/penny-1" \
    --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": "pocketsflow/penny-1",
		"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 "pocketsflow/penny-1" \
        --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": "pocketsflow/penny-1",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Ollama
How to use pocketsflow/penny-1 with Ollama:
```
ollama run hf.co/pocketsflow/penny-1:Q4_K_M
```
Unsloth Desktop

How to use pocketsflow/penny-1 with Pi:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf pocketsflow/penny-1:Q4_K_M

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": "pocketsflow/penny-1:Q4_K_M"
        }
      ]
    }
  }
}

Run Pi

# Start Pi in your project directory:
pi

Docker Model Runner
How to use pocketsflow/penny-1 with Docker Model Runner:
```
docker model run hf.co/pocketsflow/penny-1:Q4_K_M
```

Lemonade

How to use pocketsflow/penny-1 with Lemonade:

Pull the model

# Download Lemonade from https://lemonade-server.ai/
lemonade pull pocketsflow/penny-1:Q4_K_M

Run and chat with the model

lemonade run user.penny-1-Q4_K_M

List all available models

lemonade list

Hermes Agent

How to use pocketsflow/penny-1 with Hermes Agent:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf pocketsflow/penny-1:Q4_K_M

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 pocketsflow/penny-1:Q4_K_M

Run Hermes

hermes

Atomic Chat

OpenClaw

How to use pocketsflow/penny-1 with OpenClaw:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf pocketsflow/penny-1:Q4_K_M

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 "pocketsflow/penny-1:Q4_K_M" \
  --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"

Pocketsflow Penny 1

A small open decision model. Give it a situation and one question; it answers choose (one of 2–8 options), yes / no, or a 1–5 score, with a calibrated confidence, in a single forward pass. It never writes paragraphs.

The confidence is the point: send the answers it is sure about straight through, and the rest to a person.

0.6B parameters (Qwen3-0.6B, LoRA fine-tune, merged) · Apache-2.0
Runs on a CPU: Ollama, LM Studio, llama.cpp
Paper, charts and playground: https://www.pocketsflow.com/research/penny

Quick start

ollama run hf.co/pocketsflow/penny-1:Q4_K_M

Penny reads the next-token probabilities of one answer token, so call it in raw mode with the prompt format below, or use the bundled clients (penny.py, penny.mjs, zero dependencies, calibration baked in):

from penny import Penny
penny = Penny(model="hf.co/pocketsflow/penny-1:Q4_K_M")   # Ollama on localhost:11434
penny.yes_no("From: security@paypa1-support.com\nSubject: Your account is suspended\n\"We noticed unusual activity. Verify your password within 24 hours at http://paypa1-verify.co/login or your account will be closed.\"", "Is this email a phishing attempt?")
# {'yes': True, 'confidence': 0.8315}

Prompt format

<state>
any text or JSON about the situation
</state>
<question type="choice">
What should we do with this refund request?
A. Refund in full
B. Offer store credit
C. Decline politely
</question>
<answer>

The answer is the next token: a letter A–H (yes_no: A = yes, B = no) or a digit 1–5 for score. Take the softmax over the allowed tokens only and divide the logits by the per-type temperature in penny_config.json.

Results

Accuracy on held-out test sets (a score counts as right within one point). "Unseen domains" are task families that were not in training at all. API models were asked the same prompts; local models are read from logprobs.

Model	General, trained domains	General, unseen domains	Money, trained	Money, unseen	Calibration error (unseen)
Pocketsflow Penny 1	80.2%	79.9%	71.5%	66.6%	5.2%
Qwen3 0.6B (base, untrained)	55.8%	61.8%	45.6%	47.5%	25.0%
Llama 3.2 1B	50.2%	45.8%	44.4%	40.7%	–
Llama 3.2 3B	76.0%	78.6%	65.2%	69.5%	–
Llama 3.1 8B	82.7%	82.8%	68.8%	70.1%	–
Llama 3.3 70B	88.2%	87.9%	81.9%	81.3%	–
gpt-oss-20b	89.7%	92.2%	83.5%	83.3%	–

Automatic decisions. With the thresholds in penny_config.json (choice ≥ 0.79, yes_no ≥ 0.72, score ≥ 0.8): general, trained: 68.2% answered automatically at 89.2% accuracy; general, unseen: 64.5% answered automatically at 90.8% accuracy; money, trained: 46.4% answered automatically at 84.9% accuracy; money, unseen: 47.5% answered automatically at 82.4% accuracy.

Cost and speed. Q4_K_M is 397 MB. On a 4 vCPU / 8 GB server ($48/month) Penny does about 2.4 decisions a second, about $7.59 per million decisions, against $27 for Llama 3.1 8B and $63 for Llama 3.3 70B through a hosted API.

Penny is less accurate than 8B and 70B models. It is meant for the cheap, high-volume decisions where a calibrated "I'm not sure" is worth more than a few points of accuracy.

Training

Base: Qwen/Qwen3-0.6B. LoRA rank 16 on the top 14 of 28 layers, merged.
Loss on the single answer token only. Trained on a CPU.
Data: about 10,101 synthetic decisions written to a known answer by open models, kept only when a blind judge model agreed. No customer data.
Calibration: one temperature per question type, fitted on validation.

Limits

English only. Synthetic training data: real inputs will be messier.
Not for credit or lending, insurance, hiring, medical or legal decisions.
One question per call; long states are truncated.
Scores (1–5) cluster near the middle on unfamiliar inputs, and a score counts as right within one point. Prefer choose or yes / no for decisions that matter.
Not a security control: it can be confidently wrong about a dangerous agent command. Keep a hard allow-list in front of anything destructive.
Confidence is calibrated on our test sets, not on your data. Check it on a sample of your own before automating anything.

Files

File	What
`model.safetensors` + config/tokenizer	Merged model, bf16 (transformers, vLLM, TGI)
`pocketsflow-penny-1-q4_k_m.gguf`	4-bit GGUF (recommended)
`pocketsflow-penny-1-q8_0.gguf`	8-bit GGUF
`Modelfile`	Ollama model file for the Q4_K_M GGUF
`penny.py`, `penny.mjs`	Clients with calibration built in
`penny_config.json`	Per-type temperatures and auto thresholds

Citation

@misc{pocketsflow2026penny,
  title  = {Pocketsflow Penny 1: a small open decision model},
  author = {Pocketsflow Research},
  year   = {2026},
  url    = {https://www.pocketsflow.com/research/penny}
}

Downloads last month: -

Safetensors

Model size

0.6B params

Tensor type

BF16

Model tree for pocketsflow/penny-1

Base model

Qwen/Qwen3-0.6B-Base

Finetuned

Qwen/Qwen3-0.6B

Quantized

(506)

this model