AENEA AENEAQuartz Quartz aenea.app · quartz.host
PINTA-1.0 · RELEASE · APACHE-2.0

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

0Mparameters · full routing model
0taxonomy A–I · FAST / CODE / HEAVY
0%max API spend · SLM down-routing
0sustained · single CPU thread
01 · Model showcase

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.

MODEL CARDv1.0
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
DAEMON OUTPUT · ONE CALL
{"tier":"F","confidence":0.9847,
 "engine_latency_ms":640.44}
REPO ARTIFACTS

model.safetensors · 199.99 MB  |  cittern_1_50m.onnx (+.data)  |  tokenizer.json  |  vocab.json · 9,216  |  merges.txt

Model card on Hugging Face ↗

What Pinta changes for prompt routing

01

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.

02

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.

03

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.

02 · Routing taxonomy

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.

FAST down-route to SLMs · cheapest path
CODE specialist code capacity
HEAVY premium reasoning, reserved

Routing ledger

Real routing decisions from live benchmark evaluations — every prompt, tier, confidence and latency exactly as dispatched. Nothing simulated, nothing paraphrased.

03 · Evaluation

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.

0%ERA · internal SFT holdout
0%ERA · SupraLabs RouterBench
0risky failures · MMLU heavy reasoning
0throughput · CPU single-thread
4-SUITE RESULTS400 OOD prompts
Evaluation SuiteStrict / ExactCalibratedMacro-DomainEffective Routing (ERA)Mean LatencyRisky Failures
Internal SFT Holdout100.00%100.00%100.00%61.36 ms0
SupraLabs RouterBench74.00%72.00%76.00%97.00%126.82 ms2
RouteLLM LMSYS76.00%81.00%88.00%91.00%213.39 ms2
RouteLLM MMLU Battles89.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.

PINTA-1.0 · 4-SUITE NORMALIZED EVALUATION MATRIXclick to enlarge
AENEA Pinta-1.0 evaluation matrix: Internal SFT, SupraLabs, RouteLLM LMSYS and RouteLLM MMLU scored on Strict/Exact Match, Macro-Domain Alignment and Effective Routing (ERA)
Strict / exact match · macro-domain alignment · effective routing (ERA) — across Internal SFT, SupraLabs RouterBench, RouteLLM LMSYS and RouteLLM MMLU Battles.
04 · Infrastructure

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.

incoming prompt
qt.cittern-1.0 · <5 ms
pinta-1.0 · forward pass
reserved logits 23–31
A–B fastC–F codeG–I heavy
sub-65 ms

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
05 · Tokenizer benchmarks

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.

9,216vocabulary entries · 9,000 base
<5 msCPU tokenization · single thread
<4.6Membedding parameters — vs 16M+ (TinyLlama), 26M+ (Phi-2)
vocab disadvantage held at near-parity
PYTHON · PARQUET SUITE164 samples · 103,724 chars · byte-exact round-trip
Phi-251,200 vocab
QT.Cittern-1.0 (12k)12,000 vocab
QT.Cittern-1.0 (9k)9,000 vocab
TinyLlama32,000 vocab
QT.Cittern-1.0 (12k) sits within 1.4% of Phi-2's 51,200 entries — and 5.1% ahead of TinyLlama's 32k — on a vocabulary a quarter of the size.
DOMAIN SUITE · TOKEN TOTALSQT.Cittern-1.0 (9k) · fewer tokens = tighter compression
Domain / CategoryQT.Cittern-1.0 (9k)TinyLlama (32k)Phi-2 (51k)Read
Bash (Shell Scripting)377348347near-parity at 5× smaller vocab
Programming Languages7,4617,0757,006competitive subword boundaries
Scientific Formulas (STEM)6,1365,3485,571efficient 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.

TOKENIZERBENCH · 4-SUITE COMPARISONclick to enlarge
TokenizerBench compression density comparison across Bash, programming languages, human languages and scientific formulas — log scale, shorter bars are better
Bash (shell) · programming languages · human languages · scientific formulas — total tokens, log scale. Shorter bars indicate superior compression.
PYTHON · PARQUET SUITE · PUBLISHED ARTIFACTclick to enlarge
Python code compression density benchmark — QT.Cittern-1.0 (9k and 12k) versus TinyLlama (32k) and Phi-2 (51k), fewer tokens is better
The Python suite isolated: QT.Cittern-1.0 (9k & 12k) against TinyLlama (32k) and Phi-2 (51k) — fewer tokens required is better.
06 · Network

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.