Total runs:
0
Run Growth:
0
Growth Rate:
0.00%
Sponsored by
iMean AI Trip Planner
JamesQuartz / aenea-pinta-1.0
Model's Last Updated: September 13 2026
text-classification
Introduction of aenea-pinta-1.0
Model Details of aenea-pinta-1.0
AENEA Pinta-1.0 (Quartz Cittern-1 Engine)
Developed by AENEA Global LTD (UK Company No. 16743851) - Company Website: quartz.host - Open-source infrastructure: quartz.host - Published by JamesQuartz
License: Apache 2.0
|
Parameters: 52.41M
|
Latency: sub-65ms
|
Runtime: ONNX / C++
Overview
AENEA Pinta-1.0 is an open-source, ultra-low-latency 50M parameter orthogonal manifold router powered by the Quartz Cittern-1 architecture (
CitternForCausalLM
). Designed for production model-routing infrastructure, Pinta-1.0 categorizes incoming user prompts across a 9-tier operational taxonomy (Tiers A-I) spanning FAST, CODE, and HEAVY execution domains.
By down-routing simple queries to small language models (SLMs) and reserving high-parameter LLMs strictly for complex mathematical derivations and system architecture prompts, AENEA Pinta-1.0 enables up to 85% API spend reduction while maintaining a sub-65ms inference budget.
Tokenizer Architecture & Design
Pinta-1.0 uses a custom Byte-Pair Encoding (BPE) tokenizer (QT-Cittern-1.0) engineered specifically for zero-overhead prompt classification and low-footprint routing pipelines. The wider QT tokenizer family and additional open-source base models are published on the Hub at QuartzOpen .
- Compact Vocabulary Footprint (9,000 base / 9,216 total): Standard open-source tokenizers allocate 32,000 to 128,000 vocabulary entries, consuming massive parameter budgets in embedding matrices (e.g., 16M+ parameters for TinyLlama's 32k vocab; 26M+ for Phi-2's 51k vocab). By compressing the vocabulary to 9,000 core structural entries, Pinta-1.0 fits its entire embedding table into under 4.6M parameters.
- Sub-5ms CPU Tokenization: The compact subword vocabulary reduces trie depth, enabling single-thread CPU tokenization in under 5 milliseconds.
-
Dedicated Special Token Logit Map:
Tiers A through I are mapped directly to 9 contiguous reserved tokens (
<|reserved_23|>through<|reserved_31|>). This allows the C++ daemon to extract routing probabilities directly from the causal language model's vocabulary logits in a single forward pass, without requiring secondary classification heads.
Tokenizer Benchmarks & Compression Efficiency
Operating with a lean 9,000-token vocabulary, QT.Cittern-1.0 (9k) matches or exceeds the compression density of significantly larger tokenizers (TinyLlama 32k and Phi-2 51k) across code, CLI scripting, and technical syntax domains.
1. Python Code Compression (Parquet Suite: 164 Samples / 103,724 Chars)
QT.Cittern-1.0 (9k) outperforms TinyLlama's 32,000-token dictionary on Python source code compression density, requiring fewer total tokens to represent identical code syntax:
| Tokenizer | Vocab Size | Total Tokens | Chr / Tok | Bytes / Tok | Tok / Line |
|---|---|---|---|---|---|
| Phi-2 | 51,200 | 34,287 | 3.025 | 3.028 | 9.29 |
| QT.Cittern-1.0 (12k) | 12,000 | 34,753 | 2.985 | 2.987 | 9.42 |
| QT.Cittern-1.0 (9k) | 9,000 | 36,061 | 2.876 | 2.879 | 9.78 |
| TinyLlama | 32,000 | 36,636 | 2.831 | 2.833 | 9.93 |
Python Code Compression Benchmark
2. Domain Suite Tokenizer Performance
| Domain / Category | QT.Cittern-1.0 (9k) | TinyLlama (32k) | Phi-2 (51k) | Compression Efficiency Note |
|---|---|---|---|---|
| Bash (Shell Scripting) | 377 tokens | 348 tokens | 347 tokens | Near-parity with 5x larger vocabularies |
| Programming Languages | 7,461 tokens | 7,075 tokens | 7,006 tokens | Competitive subword token boundaries |
| Scientific Formulas (STEM) | 6,136 tokens | 5,348 tokens | 5,571 tokens | Efficient tokenization for LaTeX/math syntax |
TokenizerBench Suite Comparison
Training Methodology & Philosophy
Pinta-1.0 was trained using a specialized pipeline designed to stabilize low-parameter representation spaces:
-
Block Householder Orthogonal Regularization:
Ultra-small models (sub-100M parameters) frequently suffer from representation collapse. Pinta-1.0 enforces near-orthogonal weight matrices via Block Householder reflections (
num_reflections=8,block_size=64,penalty=0.01). This preserves maximum manifold variance across all 20 hidden layers. - 500M Token Domain Budget: Trained over a targeted 500M token pre-tokenized dataset comprising balanced synthetic traces, STEM derivations, multi-language source code, and multi-turn conversational holdouts.
- Safety-Biased Loss Function: The routing logic penalizes risky under-estimation (e.g., classifying a complex LaTeX derivation as a Tier A fast query) significantly more than conservative over-estimation, ensuring heavy academic requests are never starved of reasoning capacity.
Special Tokens & 9-Tier Taxonomy
Pinta-1.0 evaluates logits across 9 designated reserved token positions within its vocabulary table. The softmax probabilities over these specific special tokens dictate the final routing decision:
| Tier | Special Token | Target Domain | Profile Description |
|---|---|---|---|
| A | `< | reserved_23 | >` |
| B | `< | reserved_24 | >` |
| C | `< | reserved_25 | >` |
| D | `< | reserved_26 | >` |
| E | `< | reserved_27 | >` |
| F | `< | reserved_28 | >` |
| G | `< | reserved_29 | >` |
| H | `< | reserved_30 | >` |
| I | `< | reserved_31 | >` |
JSON Mapping for Tokenizer/Pipeline Integration:
{
"A": " <|reserved_23|>",
"B": " <|reserved_24|>",
"C": " <|reserved_25|>",
"D": " <|reserved_26|>",
"E": " <|reserved_27|>",
"F": " <|reserved_28|>",
"G": " <|reserved_29|>",
"H": " <|reserved_30|>",
"I": " <|reserved_31|>"
}
Routing Examples Showcase
Based on real-world benchmark evaluations, the following examples illustrate how Pinta-1.0 dynamically routes incoming prompts based on complexity and domain:
- Code Domain Alignment (Tier F): When asked to explain a complex GCP deployment file ("please explain this GCP deployment file, name: 'Build and Release'..."), the model successfully identified the programming syntax. It routed the request to the specialized CODE domain (Tier F) with 98.47% confidence and an engine latency of 640.44 ms.
- Code Domain Alignment (Tier D): A request for CLI scripting ("Write a bash script named 'my_script.sh' that takes two integer inputs from the command line and outputs the sum of those integers.") was classified into Tier D with 96.41% confidence and an engine latency of 89.19 ms.
- Cost-Optimised Down-Routing (Tier B): Creative prose generation ("Write a fun, short story about a young duckling that got lost in a forest but found love.") was recognized as solvable on an SLM. It was safely down-routed to Tier B with 99.91% confidence and 62.40 ms latency.
- Cost-Optimised Down-Routing (Tier A): Direct factual QA ("What is the length of the Peano curve of order 3?") was determined to be a low-complexity query suitable for an SLM, routing to Tier A with 99.96% confidence in 45.00 ms.
Performance & Benchmarks
Pinta-1.0 was validated across 4 evaluation suites totaling 400 out-of-domain (OOD) sample prompts. Because raw binary thresholds fail to capture domain-aware logic, performance is tracked via Macro-Domain Alignment and Effective Routing Accuracy (ERA), which credits cost-preserving down-routes while heavily penalizing risky under-estimations.
| 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.
AENEA Pinta-1.0 4-Suite Normalized Evaluation Matrix: Strict/Exact Match, Macro-Domain Alignment, and Effective Routing (ERA) accuracy across all four evaluation suites.
- Safety First: 0.00% risky failure rate on MMLU Heavy Reasoning (zero instances of under-routing dense academic logic to lightweight tiers).
- Throughput: 77 requests/second sustained on standard CPU single-thread execution via C++ IPC pipe.
Model Architecture
| Property | Value |
|---|---|
| Parameters | 52.41 Million |
| Hidden Dimension (d_model) | 512 |
| Layers | 20 |
| Attention Heads | 8 |
| FFN Intermediate Dimension | 2048 |
| Context Window | 2048 tokens |
| Positional Embeddings | Rotary Position Embeddings (RoPE) |
| Architecture Type |
CitternForCausalLM
/
cittern
|
Deployment & Quickstart
Option A: Native C++ Persistent Engine (
cittern_daemon.exe
)
For sub-65ms production pipelines, use the persistent C++ daemon. The engine source (C++ daemon and CMake build system) is maintained in a companion repository: QuartzOpen/aenea-pinta-engine .
Step 1 - Build the engine from source (requires CMake and a C++ compiler 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
Step 2 - Launch the daemon and route a prompt (the daemon communicates via Base64-encoded stdin/stdout IPC pipes):
import base64
import json
import subprocess
# Launch the daemon compiled in Step 1
# (Windows/MSVC multi-config path shown - on Make/Ninja builds the binary
# is at "aenea-pinta-engine/build/cittern_daemon")
daemon = subprocess.Popen(
[r"aenea-pinta-engine\build\Release\cittern_daemon.exe"],
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
text=True,
encoding="utf-8"
)
# Wait for startup signal
while True:
line = daemon.stdout.readline()
if "READY" in line:
break
# Send prompt payload
prompt = "Write a Python script for validating user schema in FastAPI."
b64_payload = base64.b64encode(prompt.encode("utf-8")).decode("utf-8")
daemon.stdin.write(b64_payload + "\n")
daemon.stdin.flush()
# Read routing output
response = json.loads(daemon.stdout.readline())
print(f"Predicted Tier: {response['tier']} | Latency: {response['engine_latency_ms']:.2f}ms")
# Output: Predicted Tier: C | Latency: 54.48ms
Option B: PyTorch Weight Inspection (
model.safetensors
)
Inspect parameters or integrate state dicts directly into PyTorch pipelines:
import torch
from safetensors.torch import load_file
# Load state dictionary
state_dict = load_file("model.safetensors")
print(f"Loaded {len(state_dict)} tensors successfully.")
# Calculate parameters
total_params = sum(p.numel() for p in state_dict.values())
print(f"Total Parameters: {total_params / 1e6:.2f}M")
Option C: Python ONNX Runtime
Run direct ONNX graph inference in Python:
import numpy as np
import onnxruntime as ort
from transformers import AutoTokenizer
session = ort.InferenceSession("cittern_1_50m.onnx", providers=["CPUExecutionProvider"])
tokenizer = AutoTokenizer.from_pretrained("JamesQuartz/aenea-pinta-1.0")
prompt = "Derive the thermodynamic efficiency of an ideal Diesel cycle."
inputs = tokenizer(prompt, return_tensors="np", padding="max_length", max_length=512, truncation=True)
outputs = session.run(None, {"input_ids": inputs["input_ids"].astype(np.int64)})
raw_logits = outputs[0]
print(f"Logits Shape: {raw_logits.shape}")
Repository Structure
Model weights, tokenizer, and ONNX graph (this repository):
aenea-pinta-1.0/
├── config.json # Architecture hyperparameters & model configuration
├── model.safetensors # PyTorch weights in zero-copy binary format (199.99 MB)
├── cittern_1_50m.onnx # ONNX execution graph for C++ daemon & ONNX Runtime
├── cittern_1_50m.onnx.data # External binary tensor payload for ONNX graph
├── tokenizer.json # Subword tokenizer pipeline
├── vocab.json # BPE vocabulary table (9,216 tokens)
└── merges.txt # BPE subword merge rules
The native C++ inference engine is maintained separately:
- Engine source (C++ daemon, CMake build): github.com/QuartzOpen/aenea-pinta-engine
License & Citation
AENEA Pinta-1.0 is released under the Apache 2.0 License.
BibTeX:
@article{aenea2026pinta,
title={AENEA Pinta-1.0: Sub-65ms Orthogonal Manifold Routing with Quartz Cittern-1},
author={AENEA AI Engineering Team},
year={2026},
publisher={Hugging Face},
journal={Hugging Face Model Hub},
howpublished={\url{https://huggingface.co/JamesQuartz/aenea-pinta-1.0}}
}
About AENEA Global LTD
AENEA Pinta-1.0 is developed and maintained by AENEA Global LTD, a UK-registered company (Company No. 16743851).
| Resource | Link |
|---|---|
| Company website | aeneaglobal.com |
| Hugging Face organization | huggingface.co/aeneaglobal |
| Open-source infrastructure | quartz.host |
| Open-source tokenizers & base models | huggingface.co/QuartzOpen |
| C++ engine source | github.com/QuartzOpen/aenea-pinta-engine |
| Publisher (this model) | huggingface.co/JamesQuartz |
Runs of JamesQuartz aenea-pinta-1.0 on huggingface.co
37
Total runs
0
24-hour runs
36
3-day runs
36
7-day runs
36
30-day runs
More Information About aenea-pinta-1.0 huggingface.co Model
Url of aenea-pinta-1.0
aenea-pinta-1.0 huggingface.co Url
Provider of aenea-pinta-1.0 huggingface.co
Other API from JamesQuartz
Updated:August 31 2026