
Base Labs released groundhog-1 on 2026-11-20, a decision model post-trained from Google's Gemma 4 26B A4B backbone. It is a 26B mixture-of-experts model with roughly 4B active parameters, built for lower latency and cost than the larger bison-1. It takes text and images with a 128k token context and returns typed answers for choice, score and yes/no questions. Weights are open on Hugging Face and the model is served through Baseten Model APIs.
A situational 26B-parameter MoE decision model from Base Labs. Treat the modality benchmarks above as the leading indicator of fit — composite scoring across modalities is still maturing. Newly released, so production-readiness is still being shaken out.
Generated from this model’s benchmarks and ranking signals. Editor reviews refine it over time.
No benchmark data available for this model yet.
Benchmark data sourced from: Hugging Face, Arena.ai, Artificial Analysis.
The top devices for this model at 4-bit, ranked by fit and speed.
| Device | Grade | VRAM |
|---|---|---|
| Acer Veriton GN100 AI MiniAcer | SS | 19.8 GB |
| AI TOP ATOM ATAGB10-9003Gigabyte | SS | 19.8 GB |
| AMD Instinct MI300XAMD | SS | 19.8 GB |
| AMD Instinct MI325XAMD | SS | 19.8 GB |
| AMD Instinct MI350PAMD | SS | 19.8 GB |
Cheapest current cloud rentals with at least 20 GB VRAM, refreshed hourly.
Advertising disclosure: we earn commissions when you shop through the links below.
| Option | Cost / GPU-hour |
|---|---|
NVIDIA GeForce RTX 3090Vast.ai · Spot · 24 GB VRAM | $0.15 |
NVIDIA RTX A5000RunPod · Community · 24 GB VRAM | $0.16 |
NVIDIA GeForce RTX 3090Vast.ai · On-Demand · 24 GB VRAM | $0.16 |
NVIDIA RTX PRO 4000 BlackwellVast.ai · Spot · 24 GB VRAM | $0.17 |
NVIDIA RTX 4000 AdaRunPod · Community · 20 GB VRAM | $0.20 |
Per-GPU rate across RunPod, the Vast.ai marketplace, DigitalOcean, and Vultr.
Spot tier is interruptible. Plan for restarts when comparing against on-demand prices.
Released on November 20, 2026, groundhog-1 is an open-weights decision model developed by Base Labs (the research division of Baseten). Built on Google's Gemma 4 26B A4B backbone, the model addresses a specific operational bottleneck: evaluating complex states and returning structured, calibrated classifications without the latency, cost, and hallucination risks of autoregressive text generation. Instead of generating text responses token-by-token, groundhog-1 inspects long-context inputs and scores discrete choices, yes/no queries, and numerical rubrics in a single pass.
The model uses a Mixture-of-Experts (MoE) architecture with 26 billion total parameters, of which roughly 4 billion are active during inference. While most general-purpose models at this weight class focus on open-ended generation, groundhog-1 operates strictly as an analytical engine. It ingests states composed of text and images, processes them across a native 131,072-token context window, and returns deterministic probability distributions over candidate answers.
For local practitioners building agentic pipelines, document classification engines, or triage systems, groundhog-1 occupies a unique tier. It provides the reasoning capacity of a mid-sized model with the execution speed of a lightweight 4B model, making it a compelling local AI model with 26B parameters in 2026 for high-throughput decision infrastructure.
The core foundation of groundhog-1 is Google's Gemma 4 26B A4B. Base Labs post-trained the base network specifically for decision tasks while freezing the vision encoder, expert router, normalization layers, and embeddings. The full fine-tune was applied exclusively to the language model weights across multimodal decision data.
The defining characteristic of groundhog-1 MoE efficiency is its sparsity:
In an MoE design, memory capacity requirements remain tied to the total parameter count (26B), because all experts must sit in VRAM to prevent offloading penalties. However, memory bandwidth and arithmetic compute loads scale primarily with the active parameter count (4B). When evaluating tokens, the router directs activations through only a subset of experts.
Unlike traditional decoder-only models that generate text sequentially, groundhog-1 evaluates questions against a shared-prefix state. When running multiple questions over a large document, the engine prefills the 128k context state once. It then computes option probabilities for every question directly from the final hidden states, eliminating the computational overhead of multi-token generation loops.
Standard large language models require complex prompt engineering, JSON schema enforcement, and constrained decoding to output reliable choices. Even with structured decoding, generative models waste compute predicting syntax tokens rather than evaluating criteria. Groundhog-1 bypasses this entirely by outputting typed answers for choice, score, and boolean questions.
Concrete local workloads where groundhog-1 excels include:
To run groundhog-1 locally, hardware planning must account for the mismatch between storage footprint (26B parameters) and compute load (4B active parameters).
Memory requirements depend heavily on quantization level and context allocation. The weights must fit completely in VRAM to achieve practical speeds. The table below outlines groundhog-1 VRAM requirements for model weights alongside working memory for standard and extended context windows:
| Quantization Format | Weights Footprint | VRAM Required (8k Context) | VRAM Required (128k Context) |
|---|---|---|---|
| FP16 / BF16 | ~52 GB | ~56 GB | ~72 GB+ |
| Q8_0 | ~28 GB | ~32 GB | ~48 GB |
| Q5_K_M | ~19 GB | ~23 GB | ~39 GB |
| Q4_K_M | ~16 GB | ~20 GB | ~36 GB |
| Q3_K_M | ~12 GB | ~15 GB | ~31 GB |
Allocating the full 131,072-token KV cache introduces significant memory overhead. For high-context local inference, running 4-bit or 8-bit KV cache quantization in engines like vLLM or llama.cpp is strongly advised.
The best quantization for groundhog-1 in production environments is Q4_K_M or Q5_K_M. Because the model maps states directly to calibrated logits rather than maintaining long-term linguistic coherence across thousands of generated tokens, 4-bit and 5-bit quantization variants retain virtually identical decision accuracy compared to full-precision weights.
In terms of groundhog-1 tokens per second, execution characteristics differ from standard generative models:
For local environments, the fastest way to get started is via Ollama or llama.cpp:
1# Pull and run the model via Ollama (once imported or published to registry)2ollama run baselabs/groundhog-1:26b-q4_k_m
For high-throughput production serving with custom structured schemas and batch processing, host the open weights through vLLM or SGLang on an internal server using their structured logit scoring endpoints.
Base Labs released groundhog-1 alongside bison-1, a 31B dense model. While bison-1 achieved top marks on the Artificial Analysis Decision Index v2.1, it evaluates all 31 billion parameters on every token. Groundhog-1 matches the performance profile of earlier frontier models like mammoth-1 while executing with only 4B active parameters. Choose bison-1 when absolute maximum classification accuracy is required and dual 48GB enterprise cards are available. Choose groundhog-1 for high-volume pipelines, edge servers, or single-GPU local workstations where latency and hardware efficiency matter.
When practitioners evaluate groundhog-1 vs. models like Qwen 2.5 32B or Gemma 2 27B for classification, the differences lie in efficiency and reliability. Running a dense 32B model locally requires asking it to output structured JSON strings, parsing those strings, and hoping formatting instructions hold. The dense model computes full-precision token generation loops for every response. Groundhog-1 executes at roughly four times the speed, requires zero token parsing, provides genuine logit calibration, and natively supports 128k context states without prompt degradation.

Explore the Provider
Aggregate stats, leaderboard, release timeline, and benchmark coverage across every Base Labs model we track.

Check which of your devices can run this model and how fast.

Compare hosted per-token prices before you commit to local hardware.

Break-even math for self-hosting, renting a GPU, or paying per token.
Live status for the hosted APIs you might use instead of running this locally.