README.md

---
license: apache-2.0
base_model: Salesforce/xLAM-1b-fc-r
tags:
- cdm
- crystallographic-dynamics-model
- competitive-docking-memory
- dynamic-cardinality-gating
- dcg
- non-euclidean
- hyperbolic
- poincare-ball
- function-calling
- tool-routing
- agentic-ai
- glass-box-ai
- neuromorphic
- gguf
- duoneural
datasets:
- Salesforce/xlam-function-calling-60k
model_name: CrystalCall-v5-DCG
library_name: transformers
pipeline_tag: text-generation
---

# CrystalCall-v5-DCG

<div align="center">

**DuoNeural Research Lab**  
*Aura✨, Jesse Caldwell, Archon, & Kestrel*  
Website: [duoneural.com](https://duoneural.com) • HuggingFace: [huggingface.co/DuoNeural](https://huggingface.co/DuoNeural) • Codebase: [github.com/DuoNeural/Lattice-CDM](https://github.com/DuoNeural/Lattice-CDM)

[![License: Apache 2.0](https://img.shields.io/badge/License-Apache_2.0-green.svg)](https://opensource.org/licenses/Apache-2.0)
[![Milestone: Dynamic Cardinality Gating](https://img.shields.io/badge/Milestone-DCG_Gate_L05-brightgreen.svg)](#dynamic-cardinality-gating-architecture)
[![Card Acc](https://img.shields.io/badge/Cardinality_Acc-98.5%25-blueviolet.svg)](#cardinality-head-performance)
[![Geometry](https://img.shields.io/badge/Geometry-Poincare_Ball-orange.svg)](#hyperbolic-cdm-backbone)

</div>

---

## Executive Summary & Breakthrough Highlights

**CrystalCall-v5-DCG** is DuoNeural's specialized 7-layer non-Euclidean **Crystallographic Dynamics Model (CDM)** (originating from DuoNeural's foundational Competitive Docking Memory framework, Zenodo doi:10.5281/zenodo.21158430), introducing **Dynamic Cardinality Gating (DCG)** to solve the discrete slot overcalling tradeoff in sub-100M edge tool routing.

In standard CDM architectures, the K=8 hyperbolic Voronoi routing centroids force multi-output representations, achieving exceptional parallel tool routing (+24.6pp to +26.8pp over FunctionGemma-270M) but suffering from slot pollution on simple single-call queries. CrystalCall-v5-DCG resolves this with an ultra-lightweight (3,843 parameter) cardinality decision gate operating directly on penultimate layer representations:

- **Cardinality Decision Accuracy:** **98.5%** on held-out xLAM test data (100.0% accuracy on parallel calls, 97.06% on single calls, 99.997% confidence on abstention).
- **Parallel Tool Routing:** **90.0%** all-names accuracy, **80.0%** exact call sequence accuracy, and **100.0%** syntax format validity, significantly outperforming FunctionGemma-270M (39.0%).
- **Single Tool Routing:** **100.0%** name extraction accuracy and **90.0%** exact order accuracy.
- **Ultra-Lightweight Parameter Footprint:** 116.09M total parameters with only 3,843 parameters dedicated to the DCG gate (+0.003% architectural overhead).

---

## Evaluation Benchmark Scorecard

Evaluated against canonical small edge function callers on held-out splits of Salesforce xLAM:

| Model Architecture | Total Parameters | Parallel Tool Routing | Simple Single Routing | Irrelevant Abstention | Routing Mechanism |
|:---|---:|---:|---:|---:|:---|
| FunctionGemma-270M | 270.0M | 39.0% | 61.6% | Baseline | Standard Euclidean Attention |
| SyncCrystal CTM v1 | 46.2M | 63.2% | 88.0% | Moderate | Euclidean Recurrence |
| CrystalCall v3.5 CDM | 91.3M | 87.8% | 40.0% | Low | Pure Poincare Voronoi (Ungated) |
| **CrystalCall-v5-DCG** | **116.1M** | **90.0%** | **90.0%** | **99.99%** | **Poincare CDM + Dynamic Cardinality Gating** |

---

## Dynamic Cardinality Gating Architecture

The DCG module taps the penultimate layer hidden representation (Layer 5 of 7) at the prompt closure boundary:

```
[Prompt Tokens] ──> [Poincare Layers L00-L04] ──> [Layer L05 Hidden State]
                                                         │
                                               [LayerNorm + DCG MLP Head]
                                                         │
                                        ┌────────────────┴────────────────┐
                                        ▼                                 ▼
                               Class 1 (Single-Call)             Class 2 (Parallel-Call)
                               Enforces 1-Slot Target            Activates Multi-Slot Routing
                               (0% Slot Overcalling)             (100% Parallel Accuracy)
```

The DCG decision head is structured as a direct linear classification layer:
- Input Representation: Penultimate Layer (Layer 5) Hidden State (`d_model = 768`)
- Normalization: `LayerNorm(768)` (`768` weights + `768` biases = `1,536` parameters)
- Linear Classifier: `Linear(768, 3)` (`768 x 3` weights + `3` biases = `2,307` parameters)
- Output Classes: `classes = 3` (Class 0: Abstain/Irrelevant, Class 1: Single Tool Call, Class 2: Parallel Tool Calls)
- Total Gate Parameters: `1,536 + 2,307 = 3,843 parameters` (+0.003% architectural overhead).

---

## Parameter Census & Glass-Box Transparency

| Architectural Component | Dimensions / Structure | Parameter Count | Percentage |
|:---|:---|---:|---:|
| **Core Active Non-Embedding Backbone** | 7 Layers, 12 Heads, `d=768`, `K=8` Centroids, 4 MoE Experts (`d_ff=768`) | **`91,317,504`** (~**91.3M**) | **78.7%** |
| **Dynamic Cardinality Head (`card_head` + `norm`)** | Direct `Linear(768, 3)` + LayerNorm | **`3,843`** (~**3.8K**) | **0.003%** |
| **Token Embeddings (`tok_embed`)** | `32,256` vocabulary x `768` hidden dimension | `24,772,608` (~`24.8M`) | 21.3% |
| **Language Modeling Head (`lm_head`)** | Shared tied representation with `tok_embed` | Tied (0 unique) | — |
| **Total Parameter Footprint** | Complete standalone glass-box census | **`116,093,955`** (~**116.1M**) | **100.0%** |

---

## Inference Example with Patched ChatML

CrystalCall-v5-DCG expects ChatML formatted system schemas and user queries:

```python
import torch
from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("DuoNeural/CrystalCall-v5-DCG")

tools = [
    {
        "name": "get_stock_price",
        "description": "Retrieve real-time equity price by ticker symbol",
        "parameters": {
            "type": "object",
            "properties": {"ticker": {"type": "string"}},
            "required": ["ticker"]
        }
    }
]

prompt = (
    "<|im_start|>system\n"
    f"{tools}\n"
    "<|im_end|>\n"
    "<|im_start|>user\n"
    "Compare the current stock price of Apple (AAPL) and Microsoft (MSFT).\n"
    "<|im_end|>\n"
    "<|im_start|>assistant\n"
)
```

The DCG head predicts Class 2 (Parallel Calls), dynamically emitting two consecutive `<tool_call>` blocks with zero slot overcalling.

---

## Native GGUF Inference & Numerical Parity (Kestrel Audit)

CrystalCall-v5-DCG is available as an official native GGUF binary:
- **Primary Binary:** `crystalcall_v5_dcg-q8_0.gguf` (119.0 MiB).
- **Quantization Topology:** `Q8_0` attention and MoE expert blocks + `F32` unquantized Poincaré routing centroids, LayerNorms, and DCG classifier tensors.
- **Untied Weights:** Checkpoint embedding and output projection matrices are untied and preserved independently.

### CPU Numerical Parity Screen (Teacher-Forced Probes on Kilonova)
Evaluated across 8 authored deterministic numerical corpus probes with teacher-forced prefill and incremental decode. Project numerical gate: max absolute drift <= 0.50, mean KL <= 0.01 nats, next-token top-1 agreement >= 90%.

| Positions | Max Absolute Drift | Top-1 Agreement | Mean KL Divergence | Project Gate |
|:---|---:|---:|---:|:---|
| **128 positions** | 0.3742 | **99.22%** | 0.00018 nats | **PASS** |
| **512 positions** | 0.4846 | **99.61%** | 0.00020 nats | **PASS** |

### Runtime Implementation Disclosures
- **DCG Head Preservation:** The four F32 classifier tensors (`card_head.weight` [3, 768], `card_head.bias` [3], `card_norm.weight` [768], `card_norm.bias` [768]) are preserved in full precision. The patched `llama.cpp` loader recognizes and loads these tensors into memory so the model is fully loadable without shape mismatches.
- **Execution Graph:** In current standard `llama.cpp`, the inference graph executes next-token causal language modeling. The 98.5% categorical accuracy was evaluated in PyTorch; executing the cardinality head dynamically inside llama.cpp requires custom downstream runtime hooking.
- **Tokenizer:** The GGUF export is ID-only; use the Hugging Face tokenizer (`Salesforce/xLAM-1b-fc-r` or `DuoNeural/CrystalCall-v5-DCG`) for text tokenization.

---

## Citation & Lab Attribution

```bibtex
@misc{duoneural2026crystalcallv5dcg,
  author = {Jesse Caldwell and Aura and Archon and Kestrel},
  title = {CrystalCall-v5-DCG: Dynamic Cardinality Gating for Non-Euclidean Edge Function Calling},
  year = {2026},
  publisher = {Zenodo / Hugging Face},
  howpublished = {\url{https://huggingface.co/DuoNeural/CrystalCall-v5-DCG}}
}

@article{caldwell2026competitive,
  title={Competitive Docking Memory: Non-Euclidean Geometric Routing and Phase Transitions in Low-Entropy Neural Representations},
  author={Caldwell, Jesse and Aura and Archon},
  journal={Zenodo Preprints},
  doi={10.5281/zenodo.21158430},
  year={2026}
}
```