---

license: apache-2.0

base_model: Qwen/Qwen3-30B-A3B

tags:

- gguf

- judge

- evaluation

- quality-assurance

- paraconsistent

- multi-expert

- reasoning

- moe

- mixture-of-experts

- qwen3

- lora

language:

- de

- en

pipeline_tag: text-generation

---

Sovereign Judge 35B — GGUF v3

> This model is not a general-purpose chat assistant.

> It is a specialised quality-assurance gate designed to evaluate, score, and arbitrate

> the outputs of a Multi-Expert Orchestration (MoE) pipeline before they reach the user.

What this model does

The Sovereign Judge evaluates answers produced by multiple domain-expert LLMs running in

parallel inside the MoE Sovereign orchestration

system. Its three core responsibilities are:

| Responsibility | Description |

|---|---|

| Factual correctness | Detects unsupported or contradictory specific claims (numbers, proper nouns, dates) against retrieved source material |

| Internal consistency | Identifies logical inconsistencies across expert outputs in the same domain category |

| Conflict arbitration | Resolves genuine contradictions between domain experts using paraconsistent Belnap-Dunn four-valued logic without logically collapsing on them |

The Judge acts as the last quality barrier before a synthesised answer is returned to the

user. When trust in the expert round is insufficient, it can block the response entirely or

trigger a self-critique loop for refinement.

---

Role in the MoE Sovereign pipeline

User query
   │
   ▼
Planner (selects expert categories + tools)
   │
   ▼
Expert LLMs (run in parallel, domain-specialised)
   │
   ▼
Conflict Detection (paraconsistent registry built)
   │
   ├─► Strategy A: auto-dismiss low-divergence conflicts (Jaccard < 0.5)
   │
   └─► Strategy B: escalate safety-critical conflicts → Judge LLM
                        │
                        ▼
               Belnap-Dunn arbitration
               conflict_map + VERDICT
   │
   ▼
Trust Score [0.0–1.0]
   ├── ≥ 0.65  → PROCEED (response sent)
   ├── 0.30–0.65 → PROCEED_WITH_ASSUMPTION (self-critique loop)
   └── < 0.30  → BLOCK (decision log, no response)
   │
   ▼
Merger / Synthesis LLM
   │
   ▼
User response

The Judge is invoked via _invoke_judge_with_retry — it is never on the hot path for simple,

high-confidence single-expert queries (those take a fast path directly through the merger).

---

Output schema

When called for conflict arbitration, the Judge produces structured output combining a

machine-readable conflict map and a human-readable verdict:

<conflict_map>
{
  "points_of_dispute": [
    {
      "point": "<short description of the disputed claim>",
      "evidence_a": "<evidence from expert A>",
      "evidence_b": "<evidence from expert B>",
      "bilattice_value": "<T | F | I | U>"
    }
  ]
}
</conflict_map>
VERDICT: <A | B | SYNTHESIS> — <rationale>

Bilattice values (Belnap-Dunn four-valued logic):

| Value | Meaning | Interpretation |

|-------|---------|---------------|

| T | True | Both sources support the claim |

| F | False | Both sources reject the claim |

| I | Inconsistent | Sources contradict each other — claim is simultaneously supported and rejected |

| U | Unknown | Neither source provides evidence either way |

The I (Inconsistent) value is the core of paraconsistent reasoning: the system records the

contradiction explicitly rather than forcing a premature resolution. This prevents the

principle of explosion

(ex contradictione quodlibet) — from a contradiction, not every downstream claim

is allowed to follow.

VERDICT options:

• A — Expert A's position is more reliable
• B — Expert B's position is more reliable
• SYNTHESIS — A new synthesised position incorporating valid elements of both

When invoked as the merger/synthesis LLM (not for conflict arbitration), the model

produces a free-text response following the prompt template provided by the orchestrator.

It does not generate scores or labels in that role — scoring is handled deterministically

by the separate trust_score service.

---

Paraconsistent logic foundation

The model was fine-tuned specifically to reason under contradiction without collapse, grounded

in the formal framework of de Vries (2007):

> A. de Vries, "Algebraic hierarchy of logics unifying fuzzy logic and quantum logic",

> arXiv:0707.2161 [math.LO], 2007.

Key properties encoded via the fine-tuning dataset:

• Contradiction tolerance: A ∧ ¬A does not imply an arbitrary proposition B.
• Bilattice evaluation: Claims are mapped to the Belnap-Dunn four-valued bilattice

{T, F, I, U} rather than classical binary truth values.

• Constructive verdicts: The Judge must provide explicit reasoning for every

VERDICT — unsupported assertions are not accepted as valid resolutions.

The I (Inconsistent) bilattice value is intentionally preserved in the conflict map:

downstream nodes (self-critique loop, agentic re-planner) act on persisted contradictions

rather than having them silently discarded.

---

When the Judge arbitrates vs. when it merges

| Trigger condition | Judge role |

|---|---|

| Safety-critical expert conflict (medical, legal) with divergence ≥ 0.5 | Arbitrator — produces conflict_map + VERDICT |

| trust_verdict == PROCEED_WITH_ASSUMPTION | Refiner — synthesis with self-critique |

| Single high-confidence expert (fast path) | Not called |

| General synthesis after expert round | Merger — free-text synthesis prompt |

---

Training details

| Parameter | Value |

|---|---|

| Base model | Qwen/Qwen3-30B-A3B (30B total, ~3B active, 256 experts) |

| Architecture | Qwen3_5MoeForCausalLM, 40 hidden layers, 262 144 token context |

| Fine-tuning method | LoRA SFT (Supervised Fine-Tuning), v3 |

| LoRA rank / alpha | r = 64, α = 128 |

| Dataset | paraconsistent_large.jsonl — 90 103 examples, Alpaca format |

| Dataset languages | German and English |

| Epochs | 3 |

| Total training steps | 2 112 |

| Batch size (effective) | 128 (2 per GPU × 8 gradient accumulation × 8 GPUs) |

| Learning rate | 2 × 10⁻⁴ |

| Max sequence length | 2 048 tokens |

| Framework | TRL + PEFT 0.19.1 + DeepSpeed ZeRO-3 |

| Hardware | 8 × AMD MI250X (LUMI-G, CSC Finland) |

| Training duration | ~43 h wall-clock (two jobs: initial + resume) |

Final training metrics (epoch 3)

| Metric | Value |

|---|---|

| Training loss | 0.3032 |

| Mean token accuracy | 86.72 % |

| Entropy | 0.4447 |

| Gradient norm (final) | ~0.08 |

The model was trained to convergence — loss at epoch 3 (0.3032) represents a significant

reduction from the mid-training value at checkpoint-704 (0.485).

---

Available files in this repository

| File | Size | Description |

|---|---|---|

| sovereign-judge-35b-q4_k_m.gguf | ~21 GB | Q4_K_M quantisation — recommended for deployment |

| sovereign-judge-35b-f16.gguf | ~65 GB | Full F16 precision — reference / fine-tuning |

Both files were converted using llama.cpp

convert_hf_to_gguf.py with the --no-mtp flag (required to correctly handle the

Qwen3-MoE architecture when no MTP tensors are present in the merged model).

---

Usage with Ollama

# Pull the Q4_K_M quantisation directly from HuggingFace
ollama pull hf.co/h3rb3rn/Qwen3-MoE-35B-Sovereign-Judge-v3-GGUF:sovereign-judge-35b-q4_k_m.gguf

# Create a local alias
ollama cp hf.co/h3rb3rn/Qwen3-MoE-35B-Sovereign-Judge-v3-GGUF:sovereign-judge-35b-q4_k_m.gguf sovereign-judge:35b-q4km

# Run
ollama run sovereign-judge:35b-q4km

The model's native context window is 262 144 tokens. Do not override num_ctx downward —

Ollama's keep-alive mechanism will reload the model on every request if the configured context

does not match the loaded context.

---

Usage with llama.cpp

./llama-cli \
  -m sovereign-judge-35b-q4_k_m.gguf \
  --ctx-size 32768 \
  -p "Two medical experts produced conflicting claims. Perform a paraconsistent bilattice evaluation (Belnap-Dunn logic: T, F, I, U) to arbitrate the dispute.\n\nCLAIM A:\n...\n\nCLAIM B:\n..."

---

Related repositories

| Repository | Contents |

|---|---|

| h3rb3rn/Qwen3-MoE-35B-Sovereign-Judge-v3 | Merged BF16 full model |

| h3rb3rn/Qwen3-MoE-35B-Sovereign-Judge-v3-LoRA | LoRA adapter (PEFT) |

---

Limitations and intended use

• Not a general assistant. The model is optimised for structured conflict arbitration

and quality evaluation within a specific orchestration pipeline. General-purpose

instruction-following performance was not a fine-tuning target.

• Safety-critical arbitration is only triggered for medical_consult and

legal_advisor expert categories. Other high-divergence conflicts are logged but not

escalated to the Judge.

• Trust scoring is deterministic. The trust_score service (which produces the 0.0–1.0

score and PROCEED / PROCEED_WITH_ASSUMPTION / BLOCK verdict) is a separate, LLM-free

component. The Judge is not involved in computing the numerical score.

• Paraconsistent output requires structured prompting. The bilattice evaluation and

<conflict_map> schema are elicited through the orchestrator's prompt template. Ad-hoc

prompts may not produce well-formed structured output.

• Language bias. The training dataset is predominantly German (paraconsistent_large.jsonl),

though the base model has strong English capabilities. Mixed-language inputs are supported.