serialhex/gemma4-12b-biblical-qlora-gt

An AI that reads the whole passage before it talks

This is the Grug-Think edition. Same questions, same answers, same sources as gemma4-12b-biblical-qlora — only the reasoning trace changed, and it changed for speed. Keep reading for why that matters, or jump straight to Quick start.

Ask a general-purpose chatbot a real theology question — "why does God let bad things happen," "did Paul really mean that," "is this verse about me or about Israel" — and you get one of two failure modes: a confident answer built on a single verse yanked out of its chapter, or three paragraphs of hedging that never actually engages the question. Neither helps you think.

This is a QLoRA fine-tune of Gemma 4 12B trained specifically not to do that. Every answer is built from reading the full pericope — the passage, the argument, the narrated scene — not an isolated verse. When the Bible genuinely holds something in tension (grace and real human response, sovereignty and freedom), the model is trained to hold it too, instead of flattening it into whichever half is easier to state. And where Christians have historically disagreed for real reasons, it says so and shows you the shape of the disagreement instead of picking a side and pretending it was never contested.

You don't need to be a seminarian for this to be useful. If you've ever had a question about a Bible passage and gotten either a Sunday-school one-liner or an answer that clearly didn't read past the one verse you quoted — that's the gap this is trying to close.

What's actually different about it

• Reads at the passage level, not the verse level. Context (who's speaking, to whom, what comes before and after) does real work in every answer, not just as a disclaimer at the end.
• Shows its reasoning. Every answer carries a think trace — the actual chain of "here's what the text says, here's what that rules out, here's the conclusion" — so you can check why, not just read a verdict.
• Doesn't dodge the hard, genuinely contested questions. Predestination, the nature of grace, sacramental theology — where real, informed Christians have disagreed across history, the model engages the disagreement instead of silently picking a denomination's answer or refusing to engage.
• Built on sources you can go check yourself. Training data is drawn from the public-domain World English Bible, the early creeds, the Didache, patristic writings, and classical logic/philosophy texts — not a black box. The dataset is CC0 and public.

Why Grug-Think: speed, not readability

Nobody reads the think trace — it's internal scratch space, not a blog post for a human audience. So the base model narrating it in full sentences ("Let me consider the context... First, I'll note that...") is pure waste: tokens generated, billed, and waited on that do nothing for output quality. Grug-Think runs every training trace through a rewrite pass targeting short, dense, declarative reasoning — the same hypothesis-and-check, the same conclusion, filler banned — so the model learns to think in way fewer tokens for identical output quality. Fewer tokens generated per answer means faster responses and lower inference cost, full stop. That's the entire point of this variant. If latency or token cost matters to you anywhere — and it basically always does — this is the model to run.

The base dataset's own card calls its original reasoning "essay-shaped, not terse" — this training data is a rewrite pass against that same complaint, done at the reasoning-trace level: see Open-Biblical-Dataset-GT for the data card and full rationale.

Pair it with retrieval for real gains

This model was trained to reason well over a passage once it has one in front of it — it was not trained as a Bible-memorization engine, and a base LLM's recall of exact wording and cross-references degrades the way any LLM's does. You will get noticeably better, more precise answers if you put it behind even a simple RAG setup: grep/embed the relevant chapter(s) for the user's question and inject the actual verse text into context before the model answers, rather than relying on it to recall the passage from training alone. Retrieval does the remembering; the model does the reading and the reasoning — that split is where this model is strongest.

Quick start

from transformers import pipeline

question = "Did Paul mean 'all have sinned' literally, or is Romans 3 making a narrower argument?"
generator = pipeline("text-generation", model="serialhex/gemma4-12b-biblical-qlora-gt", device_map="auto")
output = generator([{"role": "user", "content": question}], max_new_tokens=512, return_full_text=False)[0]
print(output["generated_text"])

Want it running locally with no GPU, no cloud, no account? Grab the GGUF build and run it with llama.cpp or Ollama.

The family

Model	What it is
gemma4-12b-biblical-qlora	Full-size Gemma 4 12B fine-tune
gemma4-12b-biblical-gguf	12B, quantized
gemma4-12b-biblical-qlora-gt	This model — Grug-Think reasoning (full-size)
gemma4-12b-biblical-gguf-gt	Grug-Think reasoning, quantized
gemma4-26b-biblical-qlora	Bigger base model (Gemma 4 26B-A4B, mixture-of-experts)
gemma4-26b-biblical-qlora-gt	26B, Grug-Think reasoning
gemma4-26b-biblical-gguf-gt	26B, Grug-Think, quantized

Known limitations

• This is a LoRA fine-tune on top of a general instruction model, not a theologian. It will be wrong sometimes. Verify anything load-bearing against the sources it cites.
• Training data skews toward Protestant evangelical framing in places even where it tries to represent other traditions fairly — spot-check before treating it as neutral across traditions.
• No automated check verifies the rewritten think traces are faithful to the original reasoning content beyond form (length, filler-phrase ban) — spot-checking is recommended if you depend on the trace itself, not just the answer.
• It is not a substitute for a pastor, a priest, a rabbi, or a therapist.

Training procedure

QLoRA SFT on serialhex/Open-Biblical-Dataset-GT, trained with TRL.

Framework versions

• TRL: 1.14.2
• Transformers: 5.21.0.dev0
• Pytorch: 2.14.1
• Datasets: 5.1.0
• Tokenizers: 0.23.2