
GS1-9B is an open-source decision model from BIGAI (Beijing Institute for General Artificial Intelligence). It returns native probability distributions over runtime-defined candidates for agent routing, verification, extraction and control, using Choice, Noul and Score primitives with zero generated output tokens. It has 8.83B stored parameters, a 262,144-token context window and a Qwen3.5 hybrid backbone with a cross-attention decision head. Weights are released under Apache-2.0 and it scores 70.45 on the Decision Index 0.4.1 public index.
A workable 8.83B-parameter dense decision model from Beijing Institute for General Artificial Intelligence. 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.
Access model weights, configuration files, and documentation.
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 | 24.1 GB |
| AI TOP ATOM ATAGB10-9003Gigabyte | SS | 24.1 GB |
| AMD Instinct MI300XAMD | SS | 24.1 GB |
| AMD Instinct MI325XAMD | SS | 24.1 GB |
| AMD Instinct MI350PAMD | SS | 24.1 GB |
Cheapest current cloud rentals with at least 24 GB VRAM, refreshed hourly.
Advertising disclosure: we earn commissions when you shop through the links below.
| Option | Cost / GPU-hour |
|---|---|
NVIDIA RTX PRO 5000 BlackwellVast.ai · Spot · 48 GB VRAM | $0.19 |
NVIDIA A40Vast.ai · Spot · 48 GB VRAM | $0.27 |
NVIDIA A40Vast.ai · On-Demand · 48 GB VRAM | $0.27 |
NVIDIA A100 80GB PCIeVast.ai · Spot · 80 GB VRAM | $0.30 |
NVIDIA RTX A6000RunPod · Community · 48 GB VRAM | $0.33 |
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.
GS1-9B is an open-source, 8.83B-parameter dense decision model developed by the Beijing Institute for General Artificial Intelligence (BIGAI). Unlike standard autoregressive large language models that generate text token-by-token to express a choice, GS1-9B is engineered as a pure "System One" decision engine. It evaluates state context against runtime-defined candidate options, outputting native, calibrated probability distributions over those candidates with exactly zero generated text tokens.
Built on an Apache-2.0 license, the model adapts a Qwen3.5 hybrid backbone and equips it with a specialized cross-attention decision head. It addresses a major bottleneck in local autonomous agent stacks: the computational overhead and parsing fragility of using generative language models for control flow, router dispatch, verification, and tool invocation. On the Decision Index 0.4.1 public benchmark, GS1-9B achieves a score of 70.45 across 43 diverse text decision tasks, setting a strong reference point for sub-10B parameter decision models.
For developers deploying local AI workflows, GS1-9B occupies a distinct functional category. Instead of replacing conversational models or coding assistants, it replaces the fragile JSON-classification prompts and logit-bias hacks commonly offloaded to generalist 7B to 14B models. Running this 8.83B parameter model locally gives you deterministic, uncertainty-aware decision routing with millisecond-scale latency on consumer GPUs.
GS1-9B uses a dense decoder structure with 8,829,078,768 stored parameters, arranged across 32 decoder layers with a hidden dimension of 4,096. Rather than relying entirely on standard multi-head self-attention, the backbone deploys a hybrid sequence-mixing architecture that interleaves three causal Gated DeltaNet (GDN) layers for every single segmented bidirectional full-attention layer.
The Gated DeltaNet layers provide linear-time state recurrence for processing long background histories and persistent prompt prefixes efficiently. The interleaved full-attention layers restore cross-sequence retrieval capabilities, utilizing carry-preserving Attention Residuals. This residual structure allows sparse attention receivers to query representations from earlier layers while anchoring computation back to the skip connection, stabilizing signal propagation through deep context.
Context handling is divided into two operational scales:
The core differentiator is the native decision head. It contains 16 decision attention heads, two candidate-routing layers, and a projection dimension of 2,048. When presented with a state prefix, a question, and candidate options, the model compiles these inputs into structured roles. Sibling candidates read their shared candidate set using segmented bidirectional attention, allowing candidates to be evaluated within their mutual comparison context without polluting the causal prefix cache.
The decision head queries these contextualized embeddings and outputs raw logits directly over the candidate set. There is no language modeling head (lm_head) in active inference. Weights are distributed in mixed storage (text and decision head in FP32, retained vision tower components in BF16), and inference runs natively in BF16 with FP32 probability reductions.
GS1-9B exposes three native typed decision primitives:
p(true).Because GS1-9B was aligned using multi-step reinforcement learning with calibrated rewards (RLCD) optimized against a Brier reward metric, its output probabilities accurately reflect true predictive variance. Practitioners can set hard mathematical thresholds for model deferral or automated fallback. If candidate confidence falls below a target value (such as 0.80), an agent can cleanly abstain, request user intervention, or query an external retrieval system rather than blindly committing to an action.
Real-world local use cases include:
Deploying GS1-9B locally requires understanding its execution profile. Traditional metrics like "GS1-9B tokens per second" apply differently here: because the model generates zero output tokens, there is no autoregressive decoding phase. Hardware latency is dominated entirely by prompt prefill and the final decision projection. A single decision over dozens of candidates resolves in a single forward pass, typically clocking under 30 to 60 milliseconds on modern hardware.
The model contains 8.83B parameters. Memory planning depends on the execution precision and context depth:
For standard classification, the best quantization for GS1-9B is Q8_0 or 8-bit equivalent formats. While Q4_K_M cuts memory usage significantly and makes it easy to learn how to run an 8.83B model on consumer GPUs with modest budgets, extreme 4-bit compression can introduce slight shifts in softmax margins for closely tied candidates. If your pipeline relies on precise calibrated confidence metrics for abstention, prefer 8-bit or native BF16 execution.
GS1-9B uses custom architecture definitions (modular_gs1.py) distributed directly with its Hugging Face repository. Running the model requires Python 3.11+, PyTorch 2.9+, and Transformers 5.3+ with trust_remote_code=True.
Because GS1-9B relies on custom routing primitives and zero-token decision heads rather than standard text-generation loops, it does not use conventional Ollama text-completion endpoints. Instead, run it locally using standard Hugging Face Transformers pipelines or the official BIGAI gs1 runtime repository, which supports CUDA Graph compilation for batched decision acceleration.
To evaluate GS1-9B performance, practitioners should compare it against standard 7B to 14B open-weights models adapted for structured extraction:
If your local AI agent architecture requires conversational replies, narrative generation, or free-form code synthesis, deploy a standard generative model like Qwen2.5 or Llama-3.1. If you need a fast, low-latency, deterministic control plane to evaluate branches, route tool calls, and verify outputs on local hardware, GS1-9B is purpose-built for that tier of your stack.

Explore the Provider
Aggregate stats, leaderboard, release timeline, and benchmark coverage across every Beijing Institute for General Artificial Intelligence 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.