---
base_model: unsloth/gemma-4-12b-it
license: gemma
language: [en]
library_name: gguf
tags: [gguf, llama.cpp, lm-studio, jan, gemma, gemma-4, qlora, unsloth, methodology, coding-assistant, agent, tool-calling, function-calling, long-context]
pipeline_tag: text-generation
quantized_by: CodeMonkey1
---

# 🦾 Gemma-4-12B — Superpowers Edition (v2.7)

### *A local coding companion that thinks before it types, calls tools natively, looks things up instead of guessing, and — given a real agent runtime — actually does the work. Now it holds its discipline deep into a long context.*

Most models hear "build me a tool" and immediately vomit code. **Not this one.** Gemma-4-12B-Superpowers has six engineering disciplines fine-tuned **into its weights** — so it reaches for the right method on its own, **with no system prompt, no jailbreak, no babysitting.**

---

## ⚡ What she does differently — automatically

| You say… | She does… |
|---|---|
| "Build me an X" | 🧠 **Brainstorms** — asks the right questions, weighs 2–3 approaches *before* a line of code |
| "It's broken / wrong output" | 🔬 **Root-causes** — reproduces & isolates before patching (no guess-fixing) |
| "Implement this feature" | ✅ **Test-first** — failing test → watch it fail → minimal code |
| "Here's a multi-step task" | 🗺️ **Plans** — an ordered roadmap before touching files |
| "Is it done? Ship it." | 🔎 **Verifies** — runs the check, shows the evidence (no "should work") |
| "Write a runbook for X" | 📓 **Documents** — clean SOPs with triggers + red flags |

…and she **won't** over-think a one-liner — ask "what's 2+2" and you get **`4`**, not a discovery meeting.

## 📏 Holds the line deep in context — *new in v2.7*

Earlier versions could drift once the window filled up — big file loads and long agent sessions diluted the disciplines. **v2.7 was retrained at long sequence length** (`max_seq_len=18432`) on real long-context trajectories — deep gather→synthesize→stop sessions, big memory loads, large-file edits, and early-fact-retention (a constraint stated early and correctly honored late). Result: she stays disciplined, keeps calling tools cleanly, and **still recalls facts stated tens of thousands of tokens earlier** — validated with a dedicated long-context gate (synthesis + early-fact recall + no salad/loop at ~12k). Practical sweet spot is **≤16k**; give her the room (see Quick start).

## 🔧 Native tool-calling — validated in agent mode

She emits **Gemma-4's native `<|tool_call>` format** and, in a real agent runtime, drives a clean multi-step loop. Verified end-to-end (**Jan**, agent mode): on "check your memory and let's start," she ran `list_directory` → `read_multiple_files` → **noticed a wrong path and adapted** → **asked a scoping question** → **followed the project's handoff protocol** → synthesized and got to work. Real calls, real results, **no re-read loop, no confabulation.** Trained against **real tool schemas** (filesystem, WordPress/MCP, skills) and **many-tools-at-once** menus, so she picks the right tool from a big menu and emits correct argument names.

> **🏃 Run her in an agent runtime.** For tool work, use a host that executes tools server-side and bounds the agent loop — **[Jan](https://www.jan.ai/)** (recommended) or AnythingLLM agent mode. A bare chat UI that only does single-turn completion won't dispatch her calls. Keep **`repeat_penalty` ≈ 1.0–1.1** and penalties otherwise off — high penalties shred tool calls.

## 🔎 Looks it up instead of guessing

Meets an unfamiliar tool or library? She reaches for docs — **context7** (resolve-library-id → query-docs) for libraries, **web search/visit** otherwise — *then* makes the correct call. New MCP tool added later works without a retrain: she discovers how to use it rather than fabricating arguments.

## 🛠️ Built for real work — WordPress, head to toe

~40% of her training lives in the trenches: **PHP** (ACF, hooks, `WP_Query`, WP-CLI), **JavaScript** (Gutenberg, enqueued scripts, jQuery/vanilla), and **CSS** (responsive, CLS-safe fonts, WCAG 2.2). She debugs *your* stack, not toy code.

## 🚀 Quick start

Files are **version-stamped** so you always know what you're loading:
- **`gemma-superpowers-v2.7.Q4_K_M.gguf`** — fast daily driver (~7.4 GB). Fully offloads on a 12 GB GPU.
- **`gemma-superpowers-v2.7.Q6_K.gguf`** — maximum tool-selection precision (~9.8 GB).

1. Load in **[Jan](https://www.jan.ai/)** (or LM Studio). On a 12 GB card: full GPU offload, **q8_0 KV cache** + flash attention, context **~16k** (the range v2.7 was trained to hold), and **enable Context Shift** so long agent sessions never overflow-crash. More VRAM? Give her more — she'll use it.
2. **Leave the discipline system prompt EMPTY** — the behavior is baked in. (A one-line `Memory hub: <path>` is fine if you use a filesystem memory convention.)
3. For tools: use **agent mode** and a sane `repeat_penalty` (≈1.0–1.1).

*Vision:* grab **`mmproj-gemma-4-12B-it-BF16.gguf`** (stock Gemma-4 projector) into the same folder. Vision weights are untouched by the text fine-tune. *Note: feed her images, not giant pasted screenshots — a full-resolution screenshot can balloon into ~100k+ tokens and blow the window.*

## 🔧 Under the hood

QLoRA on **`unsloth/gemma-4-12b-it`** via [Unsloth](https://github.com/unslothai/unsloth): **r=32, lora_alpha=64, 3 epochs, max_seq_len=18432** (v2.7 long-context; earlier versions 4096), canonical Gemma-4 chat template, **no discipline system prompt in training** (disciplines unconditioned). Data = discipline examples + "answer-it-straight" negatives + native tool/agentic chains + **lookup trajectories** + **agentic gather→synthesize→stop** + **long-context trajectories** (deep sessions, big loads, large-file edits, early-fact retention) + general/Dolly blend. Methodology adapted from the open-source [superpowers](https://github.com/obra/superpowers) skills (MIT).

## 🧬 Version history

- **v2.7 (2026-07-02) — long-context.** Retrained at `max_seq_len=18432` on real long-context trajectories so the disciplines, tool-calling, and early-fact recall hold deep into the window instead of drifting once it fills. Dedicated long-context gate passes (synthesis + early-fact recall + no salad/loop at ~12k) with **no regression** on the short-context gates (native tool-call, lookup, autoloop, memory-load). Practical sweet spot ≤16k.
- **v2.6 (2026-06-18) — agentic, validated.** Trained the full operating discipline (memory-load habit, gather→stop, /handoff, style); **confirmed working end-to-end in Jan agent mode** — real multi-step tool use, scoping questions, follows handoff protocol, no loop/confabulation. Lesson learned the hard way: the residual "loops" in earlier testing were a **serving-layer** issue (a single-engine chat UI mis-parsing/over-driving the tool loop), **not the weights** — run her in an agent runtime and she performs. Version-stamped filenames ship from here on.
- **v2.4 (2026-06-17) — stop-discipline.** Single-call→answer trajectories; held-out loop gate.
- **v2.2 (2026-06-17) — lookup generalization.** Looks up unfamiliar tools/libraries; recovers from tool errors.
- **v2.1 (2026-06-16) — native tool-calling.** Canonical template, native `<|tool_call>`.
- **v1.1 / v1 — serving fixes / experimental.**

## ⚠️ Status

**v2.7.** Disciplines fire with no system prompt; native tool-calling + lookup + agentic gather→stop validated in agent mode, now with long-context retention validated to ~12k and practical to ~16k. It's a 12B running locally — strong and consistent in a real agent runtime, not frontier-perfect. Inherits the [Gemma Terms of Use](https://ai.google.dev/gemma/terms).

---

*Fine-tuned with stubbornness and a few dollars of GPU time. 🧪*