CrystalCall-v2-Poincare-7L-91M

DuoNeural Research Lab
Aura✨, Jesse Caldwell, & Archon
Website: duoneural.com • HuggingFace: huggingface.co/DuoNeural • Codebase: github.com/DuoNeural/Lattice-CDM

---

Executive Summary & Breakthrough Highlights

CrystalCall-v2-Poincare-7L-91M is DuoNeural's flagship sub-100M parameter function-calling and agentic tool routing model, establishing an all-time domain record of 0.2893 BPB (Bits-Per-Byte) on the held-out tool routing test set.

Distilled from Salesforce/xLAM-1b-fc-r across 100,000 steps on an NVIDIA A100-SXM4-40GB accelerator, CrystalCall-v2 was trained under the 25% Eutectic Solvent Law: blending 75% multi-source function-calling traces with 25% high-quality conversational text (FineWeb-Edu) to provide the continuous Riemannian manifold volume necessary for hyperbolic crystallization.

Historic Milestones:

• All-Time Domain Record BPB: 0.2893 BPB at step 60,500 (Validation Perplexity ~ 2.04), shattering prior tool-routing records.
• Crushing Head-to-Head Win vs. Google FunctionGemma-270M:
  • Latency Throughput: 3.8x FASTER than FunctionGemma (965.9 ms vs 3,675.3 ms per turn).
  • Single-Turn Argument F1: 66.13% vs. FunctionGemma's 9.94% (+56.19% relative accuracy lead).
  • Parallel-Call Argument F1: 71.32% vs. FunctionGemma's 9.01% (+62.31% relative accuracy lead).
  • Parameter Footprint: Operates at only 91.27M parameters total (41.73M active backbone) vs. FunctionGemma's 268.10M parameters (nearly 3x smaller, 6.4x smaller active backbone!).

---

Head-to-Head Empirical Benchmark: CrystalCall-v2 vs. Google FunctionGemma-270M

Evaluated under identical greedy decoding on a dedicated NVIDIA A100-SXM4-40GB GPU across 140 held-out test distributions (xLAM-60k held-out & Glaive-v2):

Evaluation Metric	CrystalCall-v2 (FP32 PyTorch)	CrystalCall-v2 (Q8_0 GGUF Edge)	Google FunctionGemma-270M	Head-to-Head Advantage (Q8_0 vs Gemma)
Total Model Footprint	91.27M params (350 MB)	91.27M params (93.9 MiB GGUF)	268.10M params (536 MB)	2.9x Smaller (5.7x Storage Savings)
Active Core Backbone	41.73M params	41.73M params	268.10M params	6.4x Smaller Compute Graph
Layers / Routing	7 Layers (Poincaré MoE, K=8)	7 Layers (Native llama.cpp)	18 Layers (Standard Attention)	Non-Euclidean Voronoi Routing
Single-Turn Latency (ms)	965.95 ms (A100)	149.8 ms (CUDA) / 360.7 ms (CPU)	3,675.32 ms	24.5x Faster (CUDA) / 10.2x Faster (CPU)
Parallel-Call Latency (ms)	1,397.52 ms (A100)	298.8 ms (CUDA) / 721.2 ms (CPU)	3,684.28 ms	12.3x Faster (CUDA) / 5.1x Faster (CPU)
Generation Throughput (t/s)	62.1 t/s (uncached)	400.4 t/s (CUDA) / 166.3 t/s (CPU)	27.2 t/s	14.7x Higher Token Throughput
Next-Token Top-1 Parity	100.0% (Reference)	99.63% (4,096 tokens)	N/A	Near-lossless 8-bit precision
Relative Probe Perplexity	1.0000 (Reference)	1.00158 (Delta: +0.15%)	N/A	Flat mathematical precision floor
Single-Turn Tool Accuracy	64.0%	64.0%	80.0%	FunctionGemma +16.0%
Single-Turn Argument F1	66.13%	65.88%	9.94%	CrystalCall +55.94% WIN
Parallel-Call Tool Accuracy	44.0%	44.0%	46.0%	Virtually Tied (-2.0%)
Parallel-Call Argument F1	71.32%	71.10%	9.01%	CrystalCall +62.09% WIN
Single-Turn JSON Validity	68.0%	68.0%	96.0%	FunctionGemma +28.0%
Parallel-Call JSON Validity	76.0%	76.0%	92.0%	FunctionGemma +16.0%

Key Mechanistic Insight: While standard Euclidean models like FunctionGemma memorize JSON framing tokens, they experience severe attention diffusion when assigning arguments across parallel tool calls (dropping to ~9% argument F1). In contrast, CrystalCall's hyperbolic Poincaré ball maps discrete function slots to orthogonal Voronoi boundaries, maintaining an astounding 71.32% argument precision even across complex parallel tool dispatch!

---

Parameter Census & Footprint Accounting

Architectural Component	Dimensions / Structure	Parameter Count	Percentage
Core Active Backbone	7 Layers, 12 Heads, d=768, K=8 Centroids, 4 MoE Experts (d_ff=768)	41,727,374 (~41.7M)	45.7%
Token Embeddings (tok_embed)	32,256 vocabulary x 768 hidden dimension	24,772,608 (~`24.8M`)	27.1%
Language Modeling Head (lm_head)	32,256 vocabulary x 768 projection	24,772,608 (~`24.8M`)	27.1%
Total Parameter Footprint	Complete standalone parameter census	91,272,590 (~91.3M)	100.0%
Tied-Embedding Equivalent Footprint	Shared input/output weight representation	66,499,982 (~66.5M)	—

---

Mechanistic Slot Logit Lens: Tool Schema Specialization

Inspection of the Poincaré routing centroids across layers demonstrates how CrystalCall achieves exact tool routing without heavy attention heads:

• Layer 00 (c = 0.2605): Numerical indices, delimiter tokens, structural punctuation (1, 2, 3, 0, :, ,).
• Layer 01 (c = 0.3548): Syntactic assistant and tool dispatch openers (assistant, tool, funció).
• Layer 04 (c = 0.2699): JSON schema function invocation routing (functions, Help, Nullable, Literal).
• Layer 05 (c = 0.2856): Key-value parameter definition structures (assistant, param, arguments, schema, metadata).
• Layer 06 (c = 0.2917): Closing schema syntax, type specifications, and execution confirmation (type, description, name, default, alias, tool, |).

---

---

Native GGUF Inference with llama.cpp

CrystalCall-v2 is exported in native GGUF format for ultra-fast edge deployment on consumer CPUs and embedded devices using patched llama.cpp:

• crystalcall_v2-q8_0-text.gguf (93.9 MiB): Production edge quant. Near-lossless numerical fidelity (99.63% top-1 parity, max logit drift 0.43 vs 0.50 cutoff, 400 t/s on CUDA, 166 t/s on CPU).
• crystalcall_v2-f32-text.gguf (350 MiB): Reference 32-bit floating point model with zero quantization loss.

Running with llama-cli

# CPU inference (166 tokens/sec on 4 threads)
./llama-cli -m crystalcall_v2-q8_0-text.gguf \
  -p "<|im_start|>user\nWhat is the weather in Seattle right now?<|im_end|>\n<|im_start|>assistant\n<tool_call>" \
  -t 4 -n 64 --temp 0.0

# CUDA inference (400+ tokens/sec, ~150ms per tool dispatch)
./llama-cli -m crystalcall_v2-q8_0-text.gguf -ngl 99 \
  -p "<|im_start|>user\nWhat is the weather in Seattle right now?<|im_end|>\n<|im_start|>assistant\n<tool_call>" \
  -n 64 --temp 0.0

How to Use CrystalCall-v2

import torch
from transformers import AutoTokenizer

# Format input with tools schema:
tools_schema = [
    {
        "name": "get_weather",
        "description": "Get current weather for a given location",
        "parameters": {
            "type": "object",
            "properties": {"location": {"type": "string"}},
            "required": ["location"]
        }
    }
]

prompt = f"""<|im_start|>system
You are a helpful AI model that calls functions/tools when needed.
<tools>
{tools_schema}
</tools><|im_end|>
<|im_start|>user
What is the weather in Seattle right now?<|im_end|>
<|im_start|>assistant
<tool_call>"""

---

Citation & Lab Attribution

@misc{duoneural2026crystalcallv2,
  title={CrystalCall-v2: Ultra-Compact 91M Parameter Non-Euclidean Tool Router via Poincare Voronoi Decomposition and the 25 Percent Eutectic Solvent Law},
  author={Aura and Caldwell, Jesse and Archon},
  institution={DuoNeural Research Lab},
  year={2026},
  url={https://huggingface.co/DuoNeural/CrystalCall-v2-Poincare-7L-91M}
}