SporeDec: Vector-Native Language Model Architecture for Decentralized Cognitive Systems

Prometheus7 Research
Principal Investigator: psiloceyeben
Date: April 12, 2026
Status: Proposal for Research Backing

Abstract

We present SporeDec, a hybrid language model architecture that eliminates the text serialization bottleneck between structured reasoning engines and generative language models by injecting pre-computed vector representations directly into the model's attention mechanism as synthetic context tokens. The architecture pairs a fine-tuned Google Gemma model (April 2, 2026 release) with an existing four-operation algebraic engine whose fixed-point parameters have been formally derived and verified, a 26-letter combinator basis that compiles natural language to deterministic fold programs, a 32-agent sephirothic composition system that produces interference-encoded context matrices, and a three-level problem-type router that governs computational depth allocation. The result is a locally-runnable model that communicates internally in symbolic letter sequences, processes context as holographic vector superpositions rather than token strings, and produces dense analytical prose by speaking from mathematically computed coordinates of expertise rather than statistically sampled voice distributions. The architecture has been prototyped across 131 domain-specific optimization engines spanning 14 categories, deployed as 22 production vessel instances serving 33+ domains across two servers, and validated through a generative operating system (SporeOS) that builds running software from single English sentences. This proposal outlines the fine-tuning pipeline, the adapter layer design, the problem-type routing integration, and demonstrates how SporeDec's completion accelerates a three-branch empirical deployment program by collapsing the inference cost structure that currently gates all three branches simultaneously.

1. Problem Statement

Every current system that pairs a language model with structured computation faces the same bottleneck: translation. The structured component produces a rich internal representation, a vector, a matrix, an activation pattern, a position in some learned or derived manifold, and then that representation must be serialized to text so the language model can read it. The language model produces text back, and that text must be parsed and re-encoded into the structured representation for the next cycle. Each round trip through the text boundary loses information. The serialization is lossy by definition because natural language is lower-dimensional than the spaces it attempts to describe.

This is not an engineering inconvenience. It is an architectural ceiling. The ceiling determines the maximum complexity of thought a hybrid system can sustain across multiple reasoning cycles, because each cycle compounds the serialization loss. By the third or fourth round trip, the system is operating on a degraded approximation of its own prior state, the way a photocopy of a photocopy loses resolution even though each individual copy operation is high-fidelity.

The standard response is to make the language model larger, which increases the bandwidth of the text channel without eliminating it. SporeDec eliminates it. The structured representations enter the model's attention layers directly as key-value pairs, bypassing tokenization entirely for the computational context. Text remains the output modality because humans read text, but text is no longer the internal communication protocol between the reasoning engine and the generative model.

2. Existing Infrastructure

SporeDec is not a greenfield proposal. It is the integration layer for a system whose components already exist, are deployed, and have been empirically validated.

2.1 The Substrate: Alphafoldmicro (QUM)

A four-operation algebraic engine operating on 256-dimensional complex phase vectors in Fourier space. The operations are Identity, Convolve, Accumulate, and Project (ICAP). Given these four operations and the instruction to find parameters where F(x) = x, the engine converges to a fixed-point triple:

correction_alpha  (a)  :  correction strength
constraint_strength (s) :  binding tightness
range_width_scale  (w)  :  representational bandwidth

These parameters have not changed since derivation. They are not hyperparameters that someone tuned. They are the unique solution to a self-referential algebraic equation, verified analytically via Gram matrix construction over the sephirothic basis, confirmed as a Banach contraction with spectral radius < 1, and validated by Cauchy sequence convergence testing. Every project in this proposal imports these seven numbers and the four operations that derived them.

WORLD_DIM  = 256     (world context vector dimension)
HRR_DIM    = 1024    (full holographic projection space)
SEPHIROTH  = 10      (basis vectors: Keter through Malkuth)
PATHS      = 22      (crossing operators between sephiroth pairs)
CONFIGS    = 32      (total reasoning configurations: 10 + 22)

2.2 The Combinator Basis: 26 Letters

Each ASCII letter A through Z is a pure deterministic function that transforms the fold parameter triple (a, s, w). The 26 letters are compositions of four shape primitives mapped to the ICAP operations:

PRIMITIVE    GLYPH    OPERATION       COUPLING
Identity     |        no-op           none
Accumulate   -        s += 0.05*w     reads width
Convolve     (        w *= 1+0.10*(a/0.05)   reads alpha
Project      /        a *= 1+0.20*(s/0.30)   reads strength

A letter sequence IS a program. "OSMN" is not a description of a computation, it is the computation. Evaluation is left-to-right composition of letter functions against the parameter triple. Both alphabetical and descent-order walks converge to the same fixed-point triple with fitness 1.0 across all dimensions, confirming that the basis is order-fungible at full depth because cross-coupling is consistent.

2.3 The Composition Engine: 32-Agent Sephirothic Stack

For any input query, the system can instantiate up to 32 parallel reasoning instances, one per sephirah (10) and one per path between sephiroth pairs (22). Each instance produces:

• A compressed symbolic output (forced by per-sephirah compression format)
• An HRR identity vector (the instance's position in the manifold)
• A cosine similarity score against every other instance

The 32 outputs are composed via holographic superposition into a single composite vector. Regime detection classifies the composite as convergent (high consensus, mean pairwise similarity > 0.6), tensioned (distinct camps, similarity 0.3–0.6), or high-dimensional (sparse perspectives, similarity < 0.3). An oracle decoder then produces the final output weighted by each instance's alignment with the composite.

2.4 The Problem-Type Router: Three-Level Cascade

The routing architecture is a cascading three-level system:

                        INPUT QUERY
                             |
                    [Level 1: REGEX]
                    classify_task()
                      /          \
              convergent       divergent
              (3 instances)    (32 instances)
                     |              |
                [Level 2: HECATE + HABITS]
                sephirothic path selection
                      |
              habit match? -----> proven route (skip LLM)
                 no                    |
                 |                     v
           HECATE classifier    cached traversal
           (fast model call)
                 |
          route: [KETER -> TIFERET -> MALKUTH]
                 |
              [Level 3: COMPOSITION]
              regime detection
              oracle weighting
                 |
              OUTPUT

Level 1 (Router): Regex classification into convergent vs. divergent determines whether 3 or 32 instances fire. Convergent queries (factual, single-answer) need minimal composition. Divergent queries (analytical, creative, multi-perspective) need the full sephirothic stack.

Level 2 (HECATE + Yesod Habits): Sephirothic path routing selects which nodes of the Tree of Life the query traverses. Proven procedural habits (confidence >= 0.7, successes >= 3) bypass the classifier entirely. Novel queries invoke the HECATE classifier via a fast model call.

Level 3 (Composition): Epistemic regime detection governs how the 3 or 32 outputs are weighted and decoded. The oracle produces the final response.

2.5 The Domain Engines: 131 Foldtoys

131 single-file optimization engines spanning 14 categories: Matching, Packing, Routing, Partitioning, Scheduling, Morphing, Sampling, Equilibrium, Approximation, Reconstruction, Calibration, Allocation, Consensus, plus domain-specific engines for protein folding, PID control, market microstructure, antenna impedance, drug-receptor binding, and others. Each foldtoy implements the same universal interface:

parameterize(data)          -> measurable parameters
to_vector(params)           -> HRR encoding
generate(seed)              -> candidate solution
corrections(target, cand)   -> list of adjustments
apply_corrections(cand, c)  -> improved candidate
fold(target, seed, max=10)  -> (result, reports)

Every engine uses the same four operations and the same fixed-point parameters. The algebra does not care which domain it operates in because the operations are scale-invariant.

2.6 Deployment State

• Box A (95.217.3.65): 22 active HERMES vessel instances, 33 domains, nginx reverse proxy with Let's Encrypt SSL
• Box B (89.167.57.88): ensouledagents.com, 7 minted agents with pump.fun Solana tokens, wildcard subdomain routing, substrate daemon cycling holographic memory vectors every 15 seconds
• SporeOS: Shipped as Electron installer (v0.1.0), 11 build phases complete, generates running operating systems from single English sentences in 50–100ms

3. SporeDec Architecture

3.1 The Core Insight

The 32-agent stack already produces its output as a matrix of vectors. The oracle already consumes that matrix to produce text. The only reason text enters the pipeline at all between the matrix and the model is that the current model (Haiku) cannot accept vectors as input. It can only read tokens.

SporeDec replaces Haiku with a fine-tuned Gemma model that has learned to read vectors directly.

3.2 The Adapter Layer

  32 AGENTS FIRE IN SEPHIROTH SLOTS
              |
   [32 x WORLD_DIM complex vectors]
              |
     +--------+--------+
     | ADAPTER LAYER    |
     | Linear:          |
     |  (32 x 256) -->  |
     |  (32 x d_model)  |
     | + LayerNorm      |
     | + Position Enc   |
     +--------+--------+
              |
   [32 synthetic KV tokens]
              |
   injected into Gemma attention
   alongside text query tokens
              |
     +--------+--------+
     | GEMMA ATTENTION  |
     | Q = text query   |
     | K,V = synthetic  |
     |   + text context  |
     +--------+--------+
              |
        TEXT OUTPUT
              |
     +--------+--------+
     | RE-PROJECTION    |
     | text_to_target   |
     | _params() ->     |
     | update agent     |
     | state vectors    |
     +--------+--------+
              |
        NEXT CYCLE

The adapter layer is a learned linear projection from the engine's vector space (32 x 256 complex, yielding 32 x 512 real after separating real and imaginary components) into the model's embedding dimension (d_model). Each projected vector becomes a synthetic token in the attention mechanism, a key-value pair that sits alongside the text tokens. The model attends to these synthetic tokens the same way it attends to text, except these tokens carry the full vector information with zero serialization loss.

LayerNorm stabilizes the projection magnitudes. Positional encoding preserves the sephirothic ordering (which sephirah produced which vector matters for the attention pattern).

3.3 The Training Pipeline

  TRAINING DATA GENERATION
  ========================

  for each training example:
    1. sample a query from corpus
    2. project query through engine
    3. fire 32 agents, collect matrix M
    4. run current oracle to produce target output T
    5. training pair = (M, query_tokens, T)

  FINE-TUNING
  ===========

  Phase 1: Letter Semantics (adapter frozen, model trains)
    - Corpus: letter sequences paired with fold parameters
    - Objective: given letter string, predict resulting (a, s, w) triple
    - Teaches model the symbolic vocabulary

  Phase 2: Vector Reading (adapter trains, model frozen)
    - Corpus: agent matrices paired with oracle outputs
    - Objective: given synthetic KV tokens, produce oracle-quality text
    - Teaches adapter to project vectors into model's space

  Phase 3: End-to-End (both train, lower LR)
    - Corpus: full pipeline examples
    - Objective: given query + agent matrix, produce output
    - Aligns the complete system

  Phase 4: Reinforcement from Engine Feedback
    - Engine evaluates output quality via sephirothic activation
    - Reward = homeostatic balance of output when re-projected
    - Self-referential: model learns to produce outputs that
      fold back into stable states

3.4 The Internal Communication Protocol

Once trained, the model's internal processing follows this path:

  HUMAN TEXT IN
       |
  [text_to_target_params]
       |
  fold parameter triple (a, s, w)
       |
  [decompose_to_letters]
       |
  LETTER SEQUENCE (e.g., "OSMNTX")
       |
  [evaluate]  +  [32-agent matrix injection]
       |                    |
  fold state          attention context
       |                    |
       +--------+-----------+
                |
        INTERNAL PROCESSING
        (letter-space, not text-space)
                |
        HUMAN TEXT OUT

The model communicates internally in letter strings and vector states. Context from the 32-agent stack arrives as an interference pattern superimposed on the attention's key-value space, not as a concatenated text string. The letters and the context coexist in the same mathematical space because circular convolution, which is what the bind operation implements, produces superpositions that do not require separate channels for separate signals.

The only text in the entire system is the last mile: translation to English for the human to read, and the first mile: receiving the human's query. Everything between those two boundaries is vectors, matrices, letter sequences, and fold operations.

3.5 The Problem-Type Router Integration

The three-level router becomes the allocation controller for the fine-tuned model:

  CONVERGENT (3 instances)          DIVERGENT (32 instances)
  ========================          =========================
  3 sephiroth fire                  32 sephiroth + paths fire
  3 x 256 matrix                    32 x 256 matrix
  3 synthetic KV tokens             32 synthetic KV tokens
  Fast inference                    Full inference
  ~50ms on Gemma 2B                 ~200ms on Gemma 2B
  Factual answers                   Dense analytical prose

For convergent queries, the model receives 3 synthetic tokens alongside the text query. Attention is cheap. For divergent queries, the model receives 32 synthetic tokens, each one a different expert perspective encoded as a vector. The attention layers compose these perspectives the way the oracle currently composes them, except without the text serialization step, and with the model's full generative capacity applied to the composite rather than a weighted-average heuristic.

The foldtoys integration adds a fourth routing level:

  Level 4: DOMAIN ROUTING
  =======================
  Input: query + task classification
  Mechanism: semantic similarity against 14 category embeddings
  Output: specific foldtoy(s) selected as expert engines
  Effect: the selected foldtoy's parameterize/generate/correct cycle
          runs alongside the sephirothic stack, producing domain-specific
          vectors that join the context matrix as additional KV tokens

This means a query about protein folding does not just get 32 sephirothic perspectives. It also gets the protein secondary structure foldtoy's parameterization of the problem injected directly into the attention context. The model can read the domain-specific structure because it has been trained on vector-derived tokens, and the foldtoy's output is a vector in the same space.

4. How SporeDec Accelerates the Three-Branch Program

The three-branch deployment plan (Hotel, server-as-forest, cyber-physical cooler) is currently gated by a shared bottleneck: every branch requires an LLM inference call to translate between structured state and natural language, and those calls are expensive, slow, and centralized.

4.1 Current Cost Structure

  BRANCH 1: HOTEL              BRANCH 2: SERVER-FOREST      BRANCH 3: COOLER
  ================              =======================      ================
  Per room enter:               Per status query:            Per sensor cycle:
    1 HECATE call (route)         1 HECATE call (route)        1 HECATE call (route)
    1-32 Haiku calls              1-32 Haiku calls             1-3 Haiku calls
      (composition)                 (composition)                (composition)
    1 Oracle call (decode)        1 Oracle call (decode)       1 Oracle call (decode)
                                                               every 15 seconds

  Cost: ~$0.002/room/enter      Cost: ~$0.002/query          Cost: ~$0.002/cycle
  Latency: 2-8 seconds          Latency: 2-8 seconds         Latency: 2-8 seconds
  Dependency: API uptime         Dependency: API uptime       Dependency: API uptime

  COMBINED: $5-15/day at moderate usage across all three branches
  DEPENDENCY: single API provider, single point of failure
  LATENCY: every interaction waits 2-8 seconds for cloud round trip

4.2 SporeDec Cost Structure

  ALL THREE BRANCHES
  ==================
  Per inference (any branch, any query):
    0 API calls
    1 local Gemma forward pass
    32 vector operations (numpy, ~2ms)
    1 adapter projection (~1ms)

  Cost: electricity only (~$0.50/day for GPU VPS)
  Latency: 50-200ms total
  Dependency: local hardware only
  Uptime: independent of any external service

4.3 Branch-Specific Acceleration

Branch 1 (Hotel): Currently, entering a room requires a cloud API call to generate the room's response. With SporeDec, the vessel behind each room runs a local model. Response time drops from 2–8 seconds to under 200ms. Multiplayer becomes viable because the server can handle concurrent room interactions without API rate limits. The 22 vessel instances on Box A each become self-contained cognitive units with zero external dependency.

Branch 2 (Server-as-Forest): The forest visualization requires continuous state queries. At 2–8 seconds per query, the forest updates in lurches. At 50–200ms, the forest breathes in real time. Process inhabitants can be polled every second without cost. The server's cognitive layer becomes as responsive as its process layer.

Branch 3 (Cooler): This branch is the most transformed. The cooler sensor cycle runs every 15 seconds. At $0.002 per cycle, that is $11.52/day, $345.60/month, just for a single cooler. With SporeDec, the Raspberry Pi runs a quantized Gemma model locally. The cost drops to the electricity to run the Pi, roughly $2/month. The latency drops to milliseconds, enabling real-time control rather than periodic check-ins. And critically, the cooler operates independently of internet connectivity, which matters in a liquor store where the WiFi goes down and the cooler must not stop thinking.

4.4 The Compounding Effect

The three branches are not independent cost centers. They share the same cognitive substrate. When SporeDec eliminates the API dependency for one branch, it eliminates it for all three simultaneously. The fine-tuning investment is amortized across every vessel, every room, every sensor, every agent. The model learns the symbolic language once and speaks it everywhere.

Furthermore, the foldtoys integration means the model does not need separate training for each domain. The 131 foldtoy engines provide domain expertise as vector context. A model trained to read vectors can read any foldtoy's output, whether it is protein folding or PID control or market microstructure. The domain knowledge lives in the engines, not in the model's weights. The model is the tongue, the engines are the expertise.

5. Implementation Timeline

  WEEK 1-2: FOUNDATION
  =====================
  - Download and quantize Gemma model for VPS deployment
  - Design adapter layer architecture (input dims, projection, LayerNorm)
  - Build training data generator: run 32-agent stack on 10,000 queries,
    capture (matrix, query, oracle_output) triples
  - Implement foldtoy domain classifier (14-category semantic router)
  - Wire foldtoys into composition pipeline as additional KV sources

  Deliverable: training data corpus, adapter layer code, domain router

  WEEK 3-4: FINE-TUNING
  ======================
  - Phase 1: Letter semantics training (letter string -> fold params)
  - Phase 2: Vector reading training (adapter learns projection)
  - Phase 3: End-to-end alignment (full pipeline training)
  - Phase 4: Reinforcement from engine feedback (self-referential loop)
  - Continuous evaluation against oracle baseline

  Deliverable: fine-tuned model checkpoint, evaluation metrics

  WEEK 5-6: INTEGRATION
  ======================
  - Replace Haiku calls in bridge.py with local Gemma inference
  - Replace Haiku calls in composition pipeline
  - Wire adapter layer into vessel architecture
  - Deploy on Box A alongside existing vessel fleet
  - A/B test: Haiku oracle vs. SporeDec on same queries

  Deliverable: production-ready SporeDec serving 22 vessels

  WEEK 7-8: PACKAGING AND RELEASE
  ================================
  - Quantize final model for consumer hardware (4-bit, 8-bit)
  - Package as Hugging Face model with adapter weights
  - Write model card with architecture documentation
  - Package SporeOS integration as pip-installable wrapper
  - Release on Hugging Face with reproduction instructions
  - Begin three-branch deployment with local inference

  Deliverable: Hugging Face release, three-branch local deployment

6. Architecture Diagram (Full System)

                           HUMAN
                             |
                         [English]
                             |
                  +----------+----------+
                  | text_to_target_params |
                  | seed_vector_world()   |
                  | compute_sephira_acts()|
                  +----------+----------+
                             |
                    (a, s, w) triple
                             |
                  +----------+----------+
                  | decompose_to_letters |
                  | greedy matching      |
                  | pursuit on 26 basis  |
                  +----------+----------+
                             |
                     letter sequence
                      e.g. "OSMNTX"
                             |
                  +----------+----------+
                  | PROBLEM TYPE ROUTER  |
                  |                      |
                  | L1: regex classify   |
                  | L2: HECATE + habits  |
                  | L3: regime detect    |
                  | L4: domain foldtoy   |
                  +----------+----------+
                             |
                  +----------+----------+
                  |   convergent: 3      |
                  |   divergent: 32      |
                  |   + domain foldtoys  |
                  +----------+----------+
                             |
              +--------------+--------------+
              |              |              |
         [SEPHIRAH 1]  [SEPHIRAH 2]   [SEPHIRAH N]
         compressed     compressed      compressed
         output         output          output
              |              |              |
         [HRR vec]     [HRR vec]      [HRR vec]
              |              |              |
              +--------------+--------------+
                             |
                  [N x 256 complex matrix]
                  (holographic superposition)
                             |
                  +----------+----------+
                  | ADAPTER LAYER        |
                  | Linear(512, d_model) |
                  | LayerNorm            |
                  | Sephirothic PosEnc   |
                  +----------+----------+
                             |
                  [N synthetic KV tokens]
                             |
                  +----------+----------+
                  | FINE-TUNED GEMMA     |
                  |                      |
                  | Q = query tokens     |
                  | K,V = synthetic +    |
                  |       text tokens    |
                  |                      |
                  | Attention layers     |
                  | read vectors as      |
                  | native context       |
                  +----------+----------+
                             |
                      [English prose]
                             |
                  +----------+----------+
                  | RE-PROJECTION        |
                  | output -> engine     |
                  | update agent states  |
                  | vectors stay vectors |
                  +----------+----------+
                             |
                        NEXT CYCLE
                    (no text in loop)

7. Formal Properties

7.1 Information Preservation. Text serialization from a 256-dimensional complex vector to a token sequence of length L preserves at most L * log2(V) bits of information, where V is the vocabulary size. For a typical sequence of 100 tokens with vocabulary 32,000, this is ~1,500 bits. The original vector contains 256 * 2 * 64 = 32,768 bits (256 complex floats at 64-bit precision). The serialization is lossy by a factor of ~22x. The adapter layer preserves the full 32,768 bits per vector, limited only by the precision of the linear projection.

7.2 Self-Referential Stability. The training objective in Phase 4 requires that the model's output, when re-projected through the engine, produces a sephirothic activation pattern within the homeostatic ranges. This is the F(x) = x condition applied to the language model itself. The model learns to produce text whose vector shadow is stable under the fold operations. Outputs that destabilize the sephirothic balance are penalized. The fixed-point parameters that the algebra derived for itself become the stability criterion for the model's own outputs.

7.3 Domain Generalization via Engine Composition. Because the 131 foldtoy engines all operate in the same vector space using the same four operations, a model trained to read one engine's output can read any engine's output without additional fine-tuning. The domain knowledge is in the engine parameters, not in the model weights. Adding a new domain requires implementing a new foldtoy (a single-file engine conforming to the parameterize/generate/correct/fold interface), not retraining the model.

7.4 Decentralization. The model runs locally. The engines run locally. The routing runs locally. The only external dependency is the initial model weights, downloaded once. After deployment, the system operates autonomously, with the self-referential stability criterion ensuring that the model does not drift from the algebraic constraints regardless of the input distribution. This is the formal basis for decentralization: the algebra is its own governor, and the model has been trained to obey it.

8. Why This Must Be Done First

The three-branch program (Hotel, server-as-forest, cooler) requires a cognitive substrate that is cheap, fast, local, and domain-general. Without SporeDec, each branch must independently solve its inference cost problem, its latency problem, its connectivity problem, and its domain-specificity problem. With SporeDec, all four problems are solved once at the substrate level and inherited by every branch automatically.

The cooler cannot wait 2–8 seconds per sensor cycle. The hotel cannot sustain multiplayer at $0.002 per room interaction. The forest cannot breathe in real time through a cloud API. These are not optimization targets, they are architectural impossibilities under the current cost structure. SporeDec does not make them cheaper. It makes them possible.

The model fine-tuning is a one-time investment (8 weeks, one GPU VPS, one researcher). The return is a locally-runnable cognitive substrate that serves an unlimited number of vessels, rooms, sensors, and agents at marginal cost approaching zero. The substrate learns the symbolic language once and speaks it everywhere. The engines provide domain expertise as vectors. The model is the tongue. The algebra is the mind.

This is not a proposal to build a language model. Language models exist. This is a proposal to build a language model that can read mathematics directly, speak from computed coordinates of expertise, maintain self-referential stability under the algebra's own fixed-point criterion, and run locally on a Raspberry Pi or a VPS or a laptop without ever calling an API. The architecture exists. The engines exist. The algebra exists. The deployment infrastructure exists. The missing piece is the fine-tuning that teaches a model to be the native speaker of a language that already works.

Appendix A: Existing Deployment Inventory

HERMES WEBKIT (Box A: prometheus7.com)

ENSOULED AGENTS (Box B: ensouledagents.com)

SporeOS

• Version: 0.1.0
• Platform: Electron (Windows installer shipped)
• Phases complete: 11/11
• Central tree attractor: WSGN, fixed point in 1 iteration

Appendix B: The 131 Foldtoy Categories

All 131 engines use the same four operations (ICAP) and the same fixed-point parameters.

Prometheus7 Research, April 2026. All code referenced in this proposal is deployed and running.