How every inference layer of the Winnex stack relates — the spectral tokenizer, the X-Factor manifold projector, the native forward engine, Madhava bound search, weight fusion, and the Maestro that orchestrates them. One design principle connects them all: deterministic, training-free, mathematically provable operators.
Text enters the stack and moves through every layer — each one a deterministic operator — toward generation, retrieval, and orchestration.
Every character becomes a quaternion spectrum (pure arithmetic, no BPE, no vocabulary). winnex-nano — round-trip CER = 0 across 10 scripts.
The spectral state is expanded (expand_spectral: zero-pad + L2 normalize) and projected with P = XXᵀ onto the principal subspace of the model's embed_tokens. winnex-xfactor — P² = P, training-free.
The projected vector runs a native dense forward pass (RMSNorm, QKV, RoPE, GQA, SiLU MLP) — no CUDA, no GPTQ. winnex-nano — generate with persistent KV cache.
In parallel, the same spectral representation feeds the winnex-madhava bound engine for deterministic RAG — cosine, 0 bound violations by construction, per-document Cauchy-Schwarz proof.
Multiple checkpoints blend into one weight matrix via W' = Σ αᵢ R(qᵢ) Wᵢ — quaternion rotation + weighted sum, validated Σα = 1.
The JSON-driven orchestrator connects the layers to enterprise workflows — WorkRAI, Cronologia, Strategy Room — through a single UnifiedAIService gateway with RAG injection.
The unifying principle: every layer is a deterministic operator. There is no sampled graph, no random index, no learned tokenizer. The same input always produces the same spectrum, the same manifold projection, the same bound proof, and the same result — which is what makes the stack auditable end to end.
How each component connects to the others — the relationships that make the stack a single system rather than a collection of packages.
winnex-nano produces the spectral state; winnex-xfactor receives it. The connection is encode_histogram(256) → expand_spectral(D) → project. The spectral representation is the input contract both for manifold projection and for retrieval.
Relationship: nano generates the vector, xfactor places it on the model's manifold. Same deterministic input, two geometric roles.
The projected hidden state feeds the native ForwardEngine: P·ψ̃ → hidden → logits → argmax. Verified E2E on Qwen2.5-1.5B — forward produces logits, generate produces 3–5 tokens with a persistent KV cache.
Relationship: xfactor is the bridge between spectral text and a model's weight space — the piece that makes a BPE-trained model reachable without BPE.
The spectral histogram doubles as a deterministic embedding: WinnexSpectralEmbeddings → Madhava bound engine → top-K. Validated 7/8 top-1, 8/8 top-2, 0 bound violations — 100% native RAG, no external embedding service.
Relationship: the same spectral vector that drives generation also drives retrieval. One representation, two guarantees — generation and proof-based search.
Multiple model checkpoints blend into a single weight matrix with W' = Σ αᵢ R(qᵢ) Wᵢ, and the fused matrix feeds the same forward engine. Validated: fused weights preserve behavior (cos > 0.99, top-1 5/5).
Relationship: fusion and projection share the quaternion/linear-geometry language of the stack — the model itself becomes a composable, deterministic object.
The Maestro's madhava_search module indexes tenant data and injects retrieved context into every LLM call through a single UnifiedAIService hook — WorkRAI, Cronologia, Strategy Room all gain deterministic retrieval automatically.
Relationship: Madhava is the memory of the Maestro; the Maestro is the workflow that consumes it. The bound proof becomes part of the auditable business process.
The target integration: winnex-nano becomes a provider in the Maestro's UnifiedAIService, replacing SGLang on the local path. The OpenAI-compatible SSE server is the protocol bridge that makes this a drop-in swap.
Relationship: the last mile of the stack — native inference served through the same gateway as every other AI call in the enterprise.
What has been validated end to end — with the numbers — and how the layers hold together.
| Connection | Validated result | Guarantee |
|---|---|---|
| SpectralTokenizer round-trip | CER = 0 in 10 languages | Invertible, no vocabulary |
| X-Factor projection | P² = P (diff 0.000000), P(Pv) = Pv | Orthogonal projector, stable |
| Forward dense (no CUDA/GPTQ) | Qwen2.5-1.5B → logits, next-token valid | Native inference path works |
| Autoregressive generate | 3–5 tokens, persistent KV cache, param count 1.665B real | Generation mechanism works |
| Spectral → Madhava RAG | 7/8 top-1, 8/8 top-2, 0 violations | Native deterministic retrieval |
| Weight fusion | cos > 0.99, top-1 5/5, blend error 0.000000 | Fused model preserves behavior |
| X-Factor O(D²r) | D=128 → 0.042 s, D=64 → 0.006 s | Fast for practical dimensions |
What holds today: the spectral text entry works perfectly, the manifold projection is verified, native forward + generation works on a real model, spectral retrieval carries the bound proof, and weight fusion preserves behavior. Every link in the chain that is implemented has been validated end to end.
The geometric stack is built in phases. Each phase is validated before the next begins.
| Phase | Status | End-to-end evidence |
|---|---|---|
| A — X-Factor integrated + dense forward | Done | test_forward Qwen → next token |
| B — Autoregressive generation (KV cache) | Done | generate → 3–5 tokens |
| C — OpenCL backend (GPU, no CUDA) | Next | reuses Madhava kernels |
| D — Real OpenAI-compatible server | Next | SSE serving the native forward |
| E — Maestro integration (native provider) | Next | nano as winnex_local provider |
Solid. Spectral tokenizer (round-trip, benchmark), X-Factor (idempotence, real Qwen embeddings), dense forward + generation (mechanism proven), spectral RAG with bound proof (0 violations), weight fusion (preserves behavior). The deterministic core is real.
In development. GPU backend, the production OpenAI-compatible server, and the Maestro native-provider integration. Quality of generated text with the spectral path — as opposed to the mechanism — is the open frontier, to be demonstrated with standard metrics (perplexity, downstream tasks).
The honest framing: the geometric stack is a coherent, deterministic inference architecture where each implemented layer is mathematically validated. The remaining work is engineering (GPU, server, Maestro hook) and empirical demonstration of generation quality. The design principle — every layer a provable operator — is what makes the stack auditable and defensible, which is exactly its value in regulated environments.