Prompt routing,
crystallized.
AENEA Pinta-1.0 is an open-source, ultra-low-latency 52M-parameter orthogonal manifold router on the Quartz Cittern-1 architecture. It reads every incoming prompt and dispatches it across a nine-tier taxonomy — simple queries down-route to small language models, premium LLMs stay reserved for dense derivations. Up to 85% API spend reduction, sub-65ms inference on a plain CPU.
52.41M params · ONNX / C++ runtime · 9-tier taxonomy · aenea.app ⇄ quartz.host
Meet Pinta-1.0
An orthogonal manifold router whose entire job is deciding which model should answer — so your premium tier only ever sees premium problems.
- Parameters
- 52.41M
- Architecture
- CitternForCausalLM ·
cittern - Dimensions
- 20 layers · 512 hidden · 8 heads · 2048 FFN
- Context
- 2,048 tokens · RoPE
- Tokenizer
- QT.Cittern-1.0 · BPE · 9,216 entries
- Routing
- 9 tiers A–I · reserved logits 23–31
- Runtime
- ONNX graph · C++ daemon (Base64 IPC)
- Training
- 500M tokens · Block Householder regularization
- License
- Apache-2.0 · commercial use included
- Artifact
- huggingface.co/JamesQuartz/aenea-pinta-1.0
{"tier":"F","confidence":0.9847,
"engine_latency_ms":640.44}
model.safetensors · 199.99 MB | cittern_1_50m.onnx (+.data) | tokenizer.json | vocab.json · 9,216 | merges.txt
What Pinta changes for prompt routing
Nine tiers, one forward pass
Tiers A–I are mapped to nine contiguous reserved tokens (<|reserved_23|>–<|reserved_31|>). Routing probabilities are read straight from the causal LM's vocabulary logits — no secondary classification heads, no extra round-trips.
Orthogonal by construction
Sub-100M models usually suffer representation collapse. Pinta enforces near-orthogonal weight matrices via Block Householder reflections (8 reflections, block size 64), preserving maximum manifold variance across all 20 layers.
Safety-biased routing
The loss penalizes risky under-estimation far harder than conservative over-estimation — a dense LaTeX derivation is never starved of reasoning capacity. Result: zero risky failures on MMLU heavy reasoning.
Nine tiers. One decision.
Every prompt lands on exactly one tier of the operational taxonomy — A through I, spanning FAST, CODE and HEAVY execution domains. Click any tier to pull its real dispatches from the ledger below.
Routing ledger
Real routing decisions from live benchmark evaluations — every prompt, tier, confidence and latency exactly as dispatched. Nothing simulated, nothing paraphrased.
Measured on 400 prompts it had never seen.
Four out-of-domain suites. Raw binary thresholds fail to capture domain-aware logic — so performance tracks Macro-Domain Alignment and Effective Routing Accuracy (ERA), which credits cost-preserving down-routes while heavily penalizing risky under-estimation.
| Evaluation Suite | Strict / Exact | Calibrated | Macro-Domain | Effective Routing (ERA) | Mean Latency | Risky Failures |
|---|---|---|---|---|---|---|
| Internal SFT Holdout | 100.00% | — | 100.00% | 100.00% | 61.36 ms | 0 |
| SupraLabs RouterBench | 74.00% | 72.00% | 76.00% | 97.00% | 126.82 ms | 2 |
| RouteLLM LMSYS | 76.00% | 81.00% | 88.00% | 91.00% | 213.39 ms | 2 |
| RouteLLM MMLU Battles | 89.00% | 89.00% | 89.00% | 89.00% | 1040.73 ms* | 0 |
* MMLU Battles latency reflects massive multi-thousand-token few-shot context windows running on CPU execution providers.
Quartz Cittern-1
The C++ engine at the core. A persistent daemon speaking Base64 stdin/stdout IPC — 52M parameters, one ONNX graph, no GPU required. Route from any language that can open a pipe.
The full routing budget, on CPU
Tokenize (sub-5ms single-thread), one forward pass, extract tier probabilities from reserved vocab logits — all inside a 65ms inference budget on plain hardware.
77 req/s sustained
Throughput on standard CPU single-thread execution via the C++ IPC pipe. Launch the daemon once, route forever.
One graph, no heads
The whole model is cittern_1_50m.onnx. Tier probabilities are read straight from vocabulary logits — no secondary classifier heads.
Pipe-simple integration
Base64-encoded stdin/stdout speaks from Python, Go, Rust, shell scripts — anything that can open a pipe. Zero dependencies, no VM, no container required. CMake-first build, three platforms.
Deployment & quickstart
engine source · github.com/QuartzOpen/aenea-pinta-engine# Quartz Cittern-1 persistent engine (requires CMake + a C++ toolchain)
git clone https://github.com/QuartzOpen/aenea-pinta-engine.git
cd aenea-pinta-engine
mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release
cmake --build . --config Release# Launch the daemon, then route over Base64 stdin/stdout IPC # (Windows/MSVC path shown — Make/Ninja builds: aenea-pinta-engine/build/cittern_daemon) import base64, json, subprocess daemon = subprocess.Popen( [r"aenea-pinta-engine\build\Release\cittern_daemon.exe"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, text=True, encoding="utf-8") while "READY" not in daemon.stdout.readline(): pass # engine warm-up signal prompt = "Write a Python script for validating user schema in FastAPI." daemon.stdin.write(base64.b64encode(prompt.encode()).decode() + "\n") daemon.stdin.flush() r = json.loads(daemon.stdout.readline()) print(f"Tier: {r['tier']} | Latency: {r['engine_latency_ms']:.2f}ms") # → Tier: C | Latency: 54.48ms
# Direct ONNX graph inference in Python import numpy as np, onnxruntime as ort from transformers import AutoTokenizer session = ort.InferenceSession("cittern_1_50m.onnx", providers=["CPUExecutionProvider"]) tok = AutoTokenizer.from_pretrained("JamesQuartz/aenea-pinta-1.0") inputs = tok("Derive the thermodynamic efficiency of an ideal Diesel cycle.", return_tensors="np", padding="max_length", max_length=512, truncation=True) logits = session.run(None, {"input_ids": inputs["input_ids"].astype(np.int64)})[0] print(f"Logits shape: {logits.shape}")
# Inspect parameters or load state dicts into PyTorch from safetensors.torch import load_file state_dict = load_file("model.safetensors") print(f"Loaded {len(state_dict)} tensors.") total = sum(p.numel() for p in state_dict.values()) print(f"Total parameters: {total / 1e6:.2f}M") # → Total parameters: 52.41M
Engine source — C++ daemon and CMake build system — maintained at github.com/QuartzOpen/aenea-pinta-engine ↗
9k entries. 51k-vocab results.
QT.Cittern-1.0 runs a 9,000-entry BPE vocabulary where standard tokenizers spend 32,000–128,000 — and matches or exceeds their compression density across code, CLI scripting and technical syntax domains.
| Domain / Category | QT.Cittern-1.0 (9k) | TinyLlama (32k) | Phi-2 (51k) | Read |
|---|---|---|---|---|
| Bash (Shell Scripting) | 377 | 348 | 347 | near-parity at 5× smaller vocab |
| Programming Languages | 7,461 | 7,075 | 7,006 | competitive subword boundaries |
| Scientific Formulas (STEM) | 6,136 | 5,348 | 5,571 | efficient LaTeX / math syntax |
Human Languages is charted in the published TokenizerBench artifact below (log scale). QT.Cittern-9k holds near-parity with vocabularies 3.5–5.7× its size.
The wider QT tokenizer family and open-source base models are published on the Hub at huggingface.co/QuartzOpen ↗
One page. Two doors.
This exact page is served byte-for-byte from both aenea.app and quartz.host — wherever you knock, the same Pinta answers.