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

Libraries

How to use Worthify/Decision-1-E4B with Transformers:

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

pipe = pipeline("text-generation", model="Worthify/Decision-1-E4B")
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("Worthify/Decision-1-E4B")
model = AutoModelForCausalLM.from_pretrained("Worthify/Decision-1-E4B", 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 Worthify/Decision-1-E4B 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 Worthify/Decision-1-E4B:F16
# Run inference directly in the terminal:
llama cli -hf Worthify/Decision-1-E4B:F16

Install from WinGet (Windows)

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

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 Worthify/Decision-1-E4B:F16
# Run inference directly in the terminal:
./llama-cli -hf Worthify/Decision-1-E4B:F16

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 Worthify/Decision-1-E4B:F16
# Run inference directly in the terminal:
./build/bin/llama-cli -hf Worthify/Decision-1-E4B:F16

Use Docker

docker model run hf.co/Worthify/Decision-1-E4B:F16

LM Studio
Jan

vLLM

How to use Worthify/Decision-1-E4B with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/Worthify/Decision-1-E4B:F16

SGLang

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

Ollama
How to use Worthify/Decision-1-E4B with Ollama:
```
ollama run hf.co/Worthify/Decision-1-E4B:F16
```
Unsloth Desktop

How to use Worthify/Decision-1-E4B with Pi:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf Worthify/Decision-1-E4B:F16

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": "Worthify/Decision-1-E4B:F16"
        }
      ]
    }
  }
}

Run Pi

# Start Pi in your project directory:
pi

Docker Model Runner
How to use Worthify/Decision-1-E4B with Docker Model Runner:
```
docker model run hf.co/Worthify/Decision-1-E4B:F16
```

Lemonade

How to use Worthify/Decision-1-E4B with Lemonade:

Pull the model

# Download Lemonade from https://lemonade-server.ai/
lemonade pull Worthify/Decision-1-E4B:F16

Run and chat with the model

lemonade run user.Decision-1-E4B-F16

List all available models

lemonade list

Hermes Agent

How to use Worthify/Decision-1-E4B with Hermes Agent:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf Worthify/Decision-1-E4B:F16

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 Worthify/Decision-1-E4B:F16

Run Hermes

hermes

Atomic Chat

OpenClaw

How to use Worthify/Decision-1-E4B with OpenClaw:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf Worthify/Decision-1-E4B:F16

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 "Worthify/Decision-1-E4B:F16" \
  --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"

Configuration Parsing Warning:In config.json: "num_experts" must be a number

Decision-1-E4B

A smaller member of Worthify's Decision-1 family. It reads an evidence string, a criterion, and 2–16 options, then scores the declared options in one forward pass. It does not generate an answer or explanation. Scores are conditional on the supplied options and uncalibrated as decision confidence.

The upstream base is google/gemma-4-E4B-it at revision ee0ef6023621cff504d758262d4e04895a5af4a2. The resident text model has 7,463,013,376 parameters. E2B/E4B upstream names denote effective sizes; use measured file size and runtime memory when sizing a deployment. This is an independent Worthify fine-tune, not Tiny-Jev's weights or training data.

Files and local inference

This repository includes merged BF16 Transformers weights and Decision-1-E4B.F16.gguf (13.917 GiB), its hashed inference contract, and a local Electron/Node scorer. Use Node 22.12 or newer. Download this repository at an immutable revision, then:

cd electron
npm ci --ignore-scripts
node cli.mjs ../Decision-1-E4B.F16.gguf ../gguf-inference.json ../examples.jsonl cpu

For an Electron window:

./node_modules/.bin/install-electron
DECISION_MODEL="$PWD/../Decision-1-E4B.F16.gguf" \
DECISION_CONFIG="$PWD/../gguf-inference.json" \
DECISION_BACKEND=auto npm start

cpu forces CPU-only inference. auto uses an available backend with CPU fallback. Explicit cuda, metal, or vulkan requires that backend to load GPU layers. The runtime disables flash attention and uses FP32 key/value caches, including those settings when fitting GPU layers into memory. The window reports the effective backend. Linux needs a working Chromium sandbox; keep sandboxing enabled. Native modules and GGUF files must remain outside ASAR when packaging. Linux validation does not establish Windows or macOS compatibility. Evidence stays local; the renderer exposes only status/scoring IPC and has no Node or network access.

For the native FP32 CUDA path, install requirements.txt, expose exactly one CUDA GPU, and run python score.py --input examples.jsonl. Stored weights are BF16; the loader reads their exact values into FP32. FP32 computation needs about twice the weight memory of the stored 16-bit representation. Inference is single-row with autocast and TF32 disabled. score.py uses the exact saved prompt and reinstalls Gemma's FP32 final-softcap hook on each load. A plain AutoModelForCausalLM.from_pretrained call does not reinstall that Python hook. Both paths reject prompts over 2,048 tokens rather than truncating.

Training

The frozen Decision-1 v9 mixture contains 35,210 training, 3,200 validation, and 3,200 sealed-test rows. Its manifest SHA256 is 7089b3756e7ed68c9d1ee3712195ce4a0e31162736673c911542f52d8777cddd. Sources are CLINC150 (Larson et al.; CC-BY-3.0), WANLI (Liu et al.; CC-BY-4.0), MultiNLI (OANC permissive terms), and Worthify-authored examples (MIT). Exact source revisions, attributions, licenses, split rules and hashes are in data-lineage.json. Third-party raw records are not redistributed here.

Training uses the existing Decision-1 prompt, categorical cross-entropy over declared option logits, family schedule, and row-local option permutations. These smaller models use supervised LoRA on BF16 bases: rank 16, alpha 32, dropout .05, q/k/v/o projections, AdamW, seed 42, two complete epochs (4,402 updates), effective batch 16, microbatch 8, 50-update warmup to 2e-5, and gradient clipping at 1. The original 12B Decision-1 used full-parameter training with a different optimizer schedule; this run does not reproduce that method. Training ran on a local A100.

Checkpoint selection uses full validation, requires a complete unique pass and at least +.002 equal-family score over its own frozen base, and rejects retention-gate regressions beyond .02. Selected step: 4000. The sealed test was opened only after selection and merged-weight validation/reload checks. Serialization smoke checks use eight fixed reference rows. The merge must preserve unique reference maxima; an exact tie may resolve only to an originally tied maximum, within the unchanged .5-logit bound. This tie rule was amended after the first 0.6B export failed strict first-index argmax equality on an exact tie; the failed attempt and independent review are recorded in evidence/merge-policy-amendment.json. Reported metrics retain ordinary first-index argmax. Merging changed 4 of 3200 validation choices; 1 changes began at exact ties. Detailed training provenance is in training-manifest.json.

The selected adapter is merged into BF16 storage, with the disclosed merge checks above.

Evaluation

Check	Equal-family score
Frozen base validation	0.8194
Merged export validation (BF16 computation)	0.9445
Single-row FP32 native validation	0.9445
F16 GGUF validation	0.9437
Single-row FP32 native sealed test	0.8976

The aggregate averages seven family scores; the families use the metrics listed below. These are the frozen internal splits, not independent external benchmark claims. The F16 GGUF model was validated on all 3,200 validation rows; the sealed-test score above uses the exact single-row FP32 native serving policy.

Sealed-test family	Metric	Score
classification	macro_f1	0.6746
cyber	accuracy	1.0000
evidence_mnli	macro_f1	0.8596
evidence_wanli	macro_f1	0.7557
menu	accuracy	0.9932
procedural	accuracy	1.0000
uncertainty	accuracy	1.0000

F16 GGUF agrees with native choices on 99.97% of validation rows. Mean/max total variation in option probabilities: 0.00007 / 0.00674. Maximum absolute option-logit difference: 0.35816. This is approximate desktop inference, not exact numerical equivalence. CPU/CUDA parity was checked on 43 fixed validation rows covering every family, validation gate and option count; all sampled choices agreed. This is a sampled check. Peak CPU process RSS in that check was 14.590 GiB; it is not a minimum-memory guarantee and excludes GPU VRAM. First-call startup can be substantially slower than subsequent requests. Receipts and fixed acceptance thresholds are in evidence/.

The FP32/F16 serving policy was chosen after the initial 0.6B Q8_0 candidate failed numerical parity and BF16 native inference showed batch sensitivity. That failed Q8_0 candidate is not distributed. The selected checkpoint and stored BF16 tensors were unchanged for that original 0.6B candidate. This model uses the storage precision described above. Full serving validation must retain both the original selected-adapter and merged-export quality before fresh-load verification and serving-policy test evaluation. The amendment and diagnostic hashes are recorded in evidence/precision-policy-amendment.json.

The Gemma desktop scorer additionally sets GGML_CUDA_CUBLAS_COMPUTE_TYPE=f32 before scoring and requires that setting to remain unchanged for its lifetime. The installed backend promotes cuBLAS operands and computation while retaining F16 stored weights; this is not a blanket claim about every CUDA kernel. E2B's original default-cuBLAS candidate exceeded the unchanged maximum-TV gate. The failure, validation-only diagnostic and backend provenance are included in evidence/cublas-precision-policy.json and its accompanying evidence.

Limitations and provenance

Use only declared option scores; they are not calibrated truth probabilities. Performance can degrade on new domains, altered prompt formats, long evidence, or adversarial inputs. Only English string evidence, 2–16 options and 2,048-token prompts are covered by this release. No claims are made about tool safety or suitability for consequential automated decisions.

The model inherits the upstream Apache-2.0 license; bundled runtime code is MIT (see RUNTIME-LICENSE). Upstream documentation is retained in UPSTREAM-MODEL-CARD.md. The conversion uses llama.cpp revision 59778f0196a82db32580bb649d5d839355d6d7bf, with all 97 relevant Python source files verified against pinned Git objects and hashed in evidence/converter-source.json. The hash-bound wrapper is included as evidence/converter-wrapper.py. For Gemma, it translates uniform per-layer full-attention dimensions to the pinned converter's global metadata fields in memory; unsupported or conflicting overrides are rejected. The original saved config and weights remain unchanged. evidence/converter-config-adapter.json records the Gemma translation. SHA256SUMS binds every release file.