Built JefeCode Sentinel end-to-end in one session — a nightly autonomous code review service that runs on Titan, clones repos from JefeGit, and publishes findings to the JefeHQ dashboard. Started with Ollama and a single model. Hit a VRAM wall. Landed on a dual-nemotron architecture that runs entirely inside the vLLM instance already resident for JefeCode, catching 67-86% of hallucinations with a mechanical verification step.

The Build

Three parallel agents scaffolded the system in one pass: one wrote the sentinel Python CLI (Ollama client, JefeGit clone, structured JSON parsing with retry, deterministic fingerprint IDs for cross-run dedup), one added the JefeHQ Reviews tab with eight API endpoints and a SQLite schema, one created the Jenkins nightly cron job. After a brief detour restarting the wrong JefeHQ instance, everything deployed to Titan as the first vault-integrated service in the ecosystem — a single bootstrap token in .env, Discord webhook and Forgejo credentials fetched from JefeVault at runtime.

The Model Hunt

Initial sweeps with qwen2.5-coder:32b produced 58-65 findings per repo, all MINOR, mostly opinion/style dressed up as bugs. The model flagged lazy imports as "performance issues" and pydantic-settings defaults as "hardcoded secrets." Tightened the prompt with CVSS-style numeric scoring (0-10 with concrete anchors at each level) and an anti-pattern allowlist. Quality improved but severity stayed stuck at MINOR. The jefeai-lab agent ran a four-model comparison against the same prompt: qwen2.5-coder hallucinated a BLOCKER about hardcoded hotline numbers that were clearly read from settings on the same line it cited. qwen3:32b produced real findings with correct line numbers — the IP-spoofing vulnerability in the rate limiter (request.client.host collapses behind Traefik) was the kind of bug sentinel should exist to catch.

The VRAM Wall

Switching to qwen3:32b worked but each sentinel run pulled 31GB into Ollama on top of ComfyUI's 22GB and vLLM's 14GB for JefeCode. Total: 92GB / 98GB on the 96GB VRAM GPU. Scans pushed the GPU to 300W. The architectural question surfaced: we already have a capable 30B model resident in vLLM for JefeCode — nemotron-cascade-2 at 4-bit quant — why are we loading a second model into Ollama?

The Pivot

Nemotron-cascade-2 is a reasoning model. The jefeai-lab comparison had already disqualified it: 25 minutes of reasoning loops, 1.25MB of thinking text, context exhaustion, zero findings emitted. But reasoning isn't always on. NVIDIA's chat template exposes an enable_thinking kwarg, and vLLM passes it through via chat_template_kwargs. Disabled: 14.8 seconds for a three-file review, clean JSON, structured findings. Re-enabled on small per-finding prompts: reasoning actually converges because there's room (~3K prompt + 8K reasoning + answer fits in vLLM's 32K context).

The Verifier Pattern

The dual-tier architecture that emerged: the C-tier sweep runs nemotron with thinking off, fast and wide, producing candidate findings. The B-tier verifier runs nemotron with thinking on, given one candidate finding plus the code snippet it references, deciding accept/reject/downgrade. The verifier's discipline is mechanical rather than judgmental — it asks "is the described bug visible in the code I was shown?" Hallucinations get rejected because the claimed code isn't there. This works even though both tiers use the same model because the verifier's job isn't to re-reason about the problem; it's to check the candidate's claim against a specific artifact.

Results

Across three repos (jefehealth, gigi, freechat): 65 candidate findings, 48 rejected by the verifier, 4 downgraded, 14 kept. Hallucination catch rate 67-86% per repo. Total runtime ~5 minutes across all three, zero additional VRAM cost (vLLM model was already resident), zero Ollama load. Surviving findings included a legit admin-recovery bypass, missing decryption fallback on expired tokens, and four force-unwrap NPEs on Kotlin HTTP responses. A handoff doc for the two highest-severity jefehealth findings went to the planning folder for security-engineer review.

What's Next

• Sweep the remaining JefeGit repos (ourspace, jefeai, jefe-dashboard, discord_jefebot, VibeBot4000) — queued in a bash loop on Titan running overnight
• Commit sentinel to JefeGit as sentinel/ after a final gitignore/secrets audit
• Push the updated Jenkins pipeline file to evilrakir/jenkins-pipelines so the 2 AM cron actually resolves
• Iterate on precision of line references (findings sometimes cite the wrong lines even when the concern is real)

Also Shipped This Week

Same VRAM-accounting mindset drove a second deploy: swapped ComfyUI's default image model from Flux-dev (20 steps, non-commercial license) to Flux.1-schnell Q8 GGUF (4 steps, Apache 2.0). Same architecture, same text encoders, same ~12GB UNet footprint — just a distilled 4-step sampler instead of 20. Result: 2.1s hot generation at 1024×1024, roughly 10× faster than before, with no perceptible quality loss for Discord !image use. Flux-dev stays on disk as the quality fallback for jobs that need it. The license upgrade matters too: Apache 2.0 lets JefeWorks ship generated images without the dev license's non-commercial restriction. Both models now sit alongside sentinel on the same shared GPU, which is exactly why the dual-nemotron verifier pattern matters — every gigabyte saved is another model that can co-reside.

Parallel track: building out the Golden Gloom Garden toolkit for 5 acres of land stewardship — planting phase timelines, zone tracking, journal, pest & wildlife logging, property mapping, and a native-ecosystem restoration workflow for the invasive species reclamation work. Currently a single-file HTML dashboard with localStorage persistence, phased roadmap expanding into photo attachments, canvas-based property sketching, drone imagery planning, and a RAG-backed knowledge base for native plant selection. It integrates with JefeHome on the automation side (watering schedules, greenhouse climate tracking) and has its own specialist agent driving the design. Different domain entirely from Sentinel, same philosophy: local-first, file-based, no cloud dependencies, built to last.