guell00/J-Space-Deliberation

J-Space Deliberation Engine

Structured Latent Deliberation for Gemma 4 E4B using Jacobian Lens

Use our Web Interface:

👉 https://github.com/guell11/Lebron-Local-UI

---

Overview

J-Space Deliberation Engine is a latent reasoning architecture coupled to Gemma 4 E4B-it.

Inspired by Anthropic's discovery of the J-space (Global Workspace Theory), this project extends the concept beyond interpretability.

While previous work used the Jacobian Lens only to observe the model's internal representations, J-Space actively trains and structures the latent space.

Instead of allowing residual vectors to overlap chaotically, the engine introduces a 5-slot deliberation workspace inside the residual stream.

Each slot represents an isolated reasoning stage before token generation, encouraging organized internal reasoning.

---

How It Works

Structured Latent Deliberation + Native Chain-of-Thought

The J-Space module injects sparse conceptual representations into the residual stream while Gemma continues performing standard autoregressive generation.

The architecture combines:

• Continuous latent representations divided into isolated slots
• Recurrent deliberative memory
• Standard autoregressive token generation
• Jacobian Lens projections and control

---

Five Non-Overlapping Latent Workspace Slots

The internal reasoning process is organized into five strictly separated latent states.

Slot	Function	Description
Objective	Defines the goal	Maps the task objective without interference
Hypothesis	Stores candidate solutions	Keeps possible solution paths isolated
Evidence	Stores relevant signals	Filters and preserves contextual evidence
Critic	Evaluates consistency	Detects contradictions and logical errors
Commit	Produces final decision	Consolidates the latent state for text generation

---

Runtime Quantization

The Gemma 4 backbone can be executed efficiently using:

• BitsAndBytes 4-bit NF4
• PyTorch
• Accelerate

while keeping all J-Space modules in full precision.

---

Installation

pip install torch transformers accelerate bitsandbytes huggingface_hub

---

Running Inference

This example loads Gemma 4 E4B-it quantized in NF4 and attaches the structured J-Space artifacts directly from Hugging Face.

import torch

from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    BitsAndBytesConfig
)

from huggingface_hub import hf_hub_download

from lebron_jspace.reasoner import JReasonerModule


REPO_ID = "guell00/J-Space-Deliberation"

BASE_MODEL = "google/gemma-4-E4B-it"

REVISION = "fee6332c1abaafb77f6f9624236c63aa2f1d0187"


print("1. Configuring 4-bit NF4 quantization...")

quant_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True
)

print("2. Loading base model and tokenizer...")

tokenizer = AutoTokenizer.from_pretrained(
    BASE_MODEL,
    revision=REVISION
)

model = AutoModelForCausalLM.from_pretrained(
    BASE_MODEL,
    revision=REVISION,
    quantization_config=quant_config,
    device_map="auto"
)

print("3. Downloading J-Space artifacts...")

adapter_path = hf_hub_download(
    repo_id=REPO_ID,
    filename="jreasoner_adapter.pt"
)

config_path = hf_hub_download(
    repo_id=REPO_ID,
    filename="jreasoner_config.json"
)

dict_path = hf_hub_download(
    repo_id=REPO_ID,
    filename="jspace_dictionary_v3.pt"
)

print("4. Attaching J-Space Deliberation Engine...")

jspace_engine = JReasonerModule.load_from_checkpoint(
    model=model,
    adapter_path=adapter_path,
    config_path=config_path,
    dictionary_path=dict_path
)

print("Model ready for inference!")

---

Generation Example

prompt = """
user
Explain logically:

If every A is B,
and every B is C,

what can we conclude about A and C?

model
"""

inputs = tokenizer(
    prompt,
    return_tensors="pt"
).to("cuda")

with torch.no_grad():

    outputs = model.generate(
        **inputs,
        max_new_tokens=200
    )

print("\nModel Response:")

print(
    tokenizer.decode(
        outputs[0],
        skip_special_tokens=True
    )
)

---

Repository Files

File	Description
jreasoner_adapter.pt	Recurrent module weights responsible for organizing the latent workspace
jreasoner_config.json	Configuration for the five latent slots and gating mechanisms
jspace_dictionary_v3.pt	Sparse concept dictionary
jacobian_lens.pt	Jacobian Lens projection matrix
LICENSE	Apache 2.0 License

---

Architecture

                 ┌─────────────────────┐
                 │     User Prompt     │
                 └──────────┬──────────┘
                            │
                            ▼
                 ┌─────────────────────┐
                 │    Gemma 4 E4B-it   │
                 └──────────┬──────────┘
                            │
              Residual Stream Injection
                            │
                            ▼
        ┌────────────────────────────────┐
        │      J-Space Workspace         │
        │                                │
        │  Objective                     │
        │  Hypothesis                    │
        │  Evidence                      │
        │  Critic                        │
        │  Commit                        │
        └──────────────┬─────────────────┘
                       │
                       ▼
             Jacobian Lens Projection
                       │
                       ▼
                Final Text Generation

---

What is J-Space?

J-Space Deliberation Engine is an experimental latent reasoning layer that introduces a structured continuous workspace into Gemma 4, allowing the model to internally organize its reasoning process before generating tokens.

---

Original Contribution

Author

Miguel Penha Reis

Publication date:

July 26, 2026

---

Research Summary

J-Space combines several ideas into a unified latent reasoning architecture:

• Non-overlapping latent workspace slots
• Active latent-space training using Jacobian Lens
• Structured residual-stream injection
• Multi-step recurrent causal reasoning
• NF4 quantization while preserving full-precision reasoning modules

Unlike previous Jacobian Lens work, which focused primarily on interpreting latent representations, this implementation uses those representations as an active reasoning workspace.

The central proposal is a latent deliberation engine that structures internal representations into five causal compartments before autoregressive generation.

---

Related Work

Area	Difference from J-Space
Anthropic – J-space / Global Workspace	Maps the latent workspace for interpretability. J-Space actively trains and structures it.
Chain-of-Thought	Uses intermediate output tokens. J-Space operates directly in latent representations.
Recurrent Memory Networks	Maintain recurrent hidden states without an explicit structured workspace.
Activation Steering	Modifies isolated activations. J-Space builds a persistent internal reasoning structure.

---

License

Apache License 2.0

---

Citation

@software{reis2026jspace,
  author = {Miguel Penha Reis},
  title = {J-Space Deliberation Engine},
  year = {2026},
  url = {https://huggingface.co/guell00/J-Space-Deliberation},
  license = {Apache-2.0}
}

---

Author

Miguel Penha Reis

Creator of the J-Space Deliberation Engine, an experimental latent reasoning architecture for large language models built upon Gemma 4 E4B-it.

---

History

• Project created: July 26, 2026
• Architecture: J-Space Deliberation Engine
• Base model: Gemma 4 E4B-it
• Method: Structured Latent Deliberation + Jacobian Lens

---

Scientific Note

This repository presents an independent experimental research project.

Claims of originality refer specifically to the implementation provided here and to the proposed method of actively organizing latent representations into non-overlapping reasoning slots prior to token generation.

The project should be understood as an experimental exploration of structured latent reasoning rather than a claim about the capabilities or internal mechanisms of language models in general.