MODEL CARD

Amos 2.8 Model Card & Architecture

A task-conditioned text decision model designed for production systems. Discards autoregressive decoding for single-forward normalized probabilities — zero hallucinations, low latency, and calibrated confidences.

Core Specs & Configuration

SPECS

Specification	Value
Model Name	amos-2.8
Base Model	Qwen3-8B (official pretrained weights, bf16, causal LM)
Parameters	≈ 8.2B (full base) + ≈ 0.35B trainable LoRA parameters
Adapter	LoRA r=32 / α=64, full 7-module projection (349MB safetensors), nf4-double quantized training
Context	max_len = 896 tokens (base limit 40,960)
Output protocol	systemone primitives (choice / score / noul), constrained decoding with normalized probabilities + confidence
Training	QLoRA curriculum fine-tuning (50,567 curriculum rows + sha1 dual-layer exclusion)
Benchmarks	4-round blind-test mean 97.45% ±0.6pp; R3 shared-board 96.6% #1; strict OOD 96.05% leads jev-1.13
Latency (Tested)	≈950–1200 ms (public e2e); 0 API errors across 2,000 real calls

SELF-HOSTED

Private Deployment

Fully offline single-node private deployment: the Qwen3-8B base plus LoRA adapter run entirely on your own GPU environment — data never leaves your intranet, and the API is identical to the public endpoint. A single 24GB card (RTX 4090/3090) is enough.

Requirements

Item	Minimum	Notes
GPU	Single NVIDIA GPU, ≥ 16GB (4-bit quantized ≈6GB) · 24GB recommended (bf16)	bf16 base ≈16GB + adapter ≈0.7GB; 4-bit quantized loading drops to ≈6GB; consumer (RTX 4090/3090) or datacenter cards both supported
Memory	≥ 32GB	Weight loading and runtime buffers
Disk	≥ 20GB free space	Qwen3-8B base (≈16GB) + adapter (349MB) + tokenizer
OS	Linux x86_64	NVIDIA driver and CUDA runtime required
Dependencies	Python 3.10+ / torch / transformers / peft / safetensors	vLLM requires merging weights first (merge_and_unload), then saving
Network	Fully offline capable	No internet access needed; data stays on the intranet
Weight check	sha256-verify adapter_model.safetensors	75ca2c3b596bdfd493e148474fc7b34713cae7d1c6fac5e1fa9da17a2e6d4a4e

HF repo: huggingface.co/unfork/amos-2.8 →

Deployment Steps

Fetch weights → load base + adapter → start the local inference service in three steps; the local endpoint is request/response-compatible with the public one.

1. Fetch Weights and Load Base + Adapter (self-hosting recommended)

python# pip install torch transformers peft safetensors
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import PeftModel

base = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3-8B", torch_dtype=torch.bfloat16, device_map="auto"
)
model = PeftModel.from_pretrained(base, "unfork/amos-2.8")
model.eval()

tok = AutoTokenizer.from_pretrained("unfork/amos-2.8")

2. Build the systemone Request and Infer (identical to production)

python# systemone request construction (identical to production)
state = "Your account has been credited with $500. Click http://x.com to claim now"
question = "SMS category?"
criteria = {"promotional": "Option A", "phishing_scam": "Option B",
            "transaction_alert": "Option C", "otp_code": "Option D"}
prompt = f"{state}\n{question}\n" + "\n".join(f"{k}: {v}" for k, v in criteria.items())
inputs = tok(prompt, return_tensors="pt").to(model.device)
out = model.generate(**inputs, max_new_tokens=64)
print(tok.decode(out[0], skip_special_tokens=True))

3. vLLM Deployment (optional; merge weights first)

bash# 1) Merge the adapter into the base and save full weights
#    model = model.merge_and_unload(); model.save_pretrained("./amos-2.8-merged")

# 2) Start an OpenAI-compatible vLLM service (port 8000)
python -m vllm.entrypoints.openai.api_server \
  --model ./amos-2.8-merged \
  --served-model-name amos-2.8 \
  --port 8000

For enterprise private deployment and customization, contact hello@unfork.ai; weights and the inference service run fully offline on your intranet. Note: HuggingFace Serverless Inference does not support direct LoRA-adapter inference; self-hosting is the recommended path.

systemone Primitives Interface

PRIMITIVES

choice

Multiple-choice over a candidate set: returns option probabilities and the argmax decision.

score

Ordered scoring: returns numerical scores and distribution over buckets.

noul

Open judgment without preset choices: returns label confidence probabilities.

Intended Use & Out-of-Scope Bounds

BOUNDS

Intended Use Production text judgment: intent classification, risk grading, sentiment polarity, topic classification, language ID, PII detection, moderation, extraction, dedup; routing, fallback, and escalation pipelines requiring structured probabilities and confidence; batch processing of mixed EN/ZH short texts. The 17-category blind test covers SST/AG News/NLI/MMLU/GSM8K and more, with most categories at 93%+.

Out of Scope Free-form text generation and dialogue authoring (output constrained by the systemone protocol); long documents over 896 tokens; character-level exact counting (a known generative-tokenizer difficulty); accuracy guarantees for task types entirely absent from training (open-set generalization unverified).

Quickstart (Inference Code)

QUICKSTART

1. CURL Calling Official Endpoint (systemone choice primitive)

bashcurl -X POST https://api.unfork.ai/v1/systemone \
  -H "Content-Type: application/json" \
  -d '{
    "model": "amos-2.8",
    "task": "choice",
    "text": "Refund request is 3 days overdue, but credit history is excellent. Approve automatically?",
    "candidates": ["approve", "reject", "escalate_to_human"]
  }'

2. Python Client Example (with calibrated confidence & escalation)

pythonimport requests

ENDPOINT = "https://api.unfork.ai/v1/systemone"

payload = {
    "task": "choice",
    "text": "Large withdrawal request from an unusual location",
    "candidates": ["allow", "challenge_otp", "block_and_alert"]
}

res = requests.post(ENDPOINT, json=payload).json()
decision = res["decision"]
confidence = res["calibrated_confidence"]

# Route automatically based on calibrated confidence
if confidence < 0.85:
    route_to_human_triage(payload["text"], reason="low_calibrated_conf")
else:
    execute_action(decision)

Amos 2.8 builds on official Qwen3-8B weights plus a QLoRA adapter; a single 24GB GPU (bf16) handles loading and inference. Weights are published on the public HuggingFace repo (unfork/amos-2.8).