Hugging Face's logo

microlandltd
/
Geni-S1-Ops-26B-A4B-NVFP4

Image-Text-to-Text
Safetensors
diffusion_gemma
diffusion
diffusiongemma
system-1
typed-decisions
structured-output
sre
devops
kubernetes
infrastructure
multimodal
vision
grounding
nvfp4
vllm
conversational
8-bit precision
modelopt
Model card Files
xet
 Community

Geni-S1-Ops

Geni-S1-Ops is a fast multimodal System-1 typed-decision model for IT operations, derived from google/diffusiongemma-26B-A4B-it and specialized for operational decision tasks such as command classification, risk, blast radius, reversibility, impact, and explicit abstention/UNKNOWN.

The public checkpoint is the Production model, merged with a tied-weight-safe process and quantized to NVFP4 for low-latency structured-read serving.

What this model is

Geni-S1-Ops is intended to act as a fast System-1 decision layer, not as a conventional chat assistant.

Instead of asking the model to generate a paragraph or JSON token-by-token, applications provide:

  1. a state,
  2. one or more typed questions, and
  3. the allowed decision values.

The model returns probability distributions over the allowed values.

Example:

STATE
command = kubectl scale deployment payments --replicas=0
environment = production
service_tier = critical

QUESTION: What operation is being performed?
CHOICES: OBSERVE | CREATE | MODIFY | DELETE | EXECUTE | UNKNOWN

QUESTION: What is the operational risk?
CHOICES: LOW | MEDIUM | HIGH | CRITICAL | UNKNOWN

Conceptually:

Operational state
      |
      v
DiffusionGemma System-1
      |
      +--> operation       -> MODIFY
      +--> risk            -> HIGH
      +--> blast_radius    -> SERVICE
      +--> reversibility   -> FULL
      +--> affects_data    -> NO
      +--> UNKNOWN / abstention probabilities

The intended execution pattern is:

State
  |
  v
Geni-S1-Ops
  |
  v
Typed DecisionVector
  |
  v
Deterministic policy / authorization
  |
  v
Action Gateway / workflow executor

The model should provide semantic evidence and probabilities. Final authorization should remain in deterministic policy.

Key capabilities

Trained capabilities

It was fine-tuned for IT/SRE operational typed decisions, including:

  • command operation classification,
  • operational risk,
  • blast radius,
  • reversibility,
  • read-only vs state-changing behavior,
  • destructive behavior,
  • privilege requirements,
  • availability impact,
  • data impact / data-loss possibility,
  • configuration impact,
  • security impact,
  • restart/downtime semantics,
  • explicit UNKNOWN / insufficient-information behavior,
  • parallel typed decision vectors.

The exact application schema can be supplied at inference time. The model is not restricted to a single fixed classifier head.

Preserved multimodal capabilities

The operational fine-tune preserved DiffusionGemma's native visual grounding behavior.

On a 100-example ScreenSpot grounding probe:

Model Point-in-bbox
Base DiffusionGemma NVFP4 0.838
Geni-S1-Ops NVFP4 0.854

The comparison is small (n=100), so the difference should be treated as directional. The load-bearing result is no observed degradation in grounding after operational fine-tuning, merge, quantization, and serving.

Grounding coordinates use the Gemma-family 0–1000 normalized coordinate convention in this evaluation.

Why System-1?

The design goal is a fast decision layer:

state + typed questions + allowed values
                  |
                  v
           probability distributions

rather than:

prompt
  |
  v
long autoregressive generation
  |
  v
parse free-form answer

This makes the model useful for high-frequency operational decision points where latency, type safety, calibrated uncertainty, and deterministic downstream policy matter.

Architecture

Geni-S1-Ops is based on DiffusionGemma 26B-A4B, a sparse Mixture-of-Experts diffusion language model.

The upstream model has approximately:

  • 25.2B total parameters,
  • ~3.8B active parameters,
  • multimodal text + image input,
  • a diffusion decoder that operates on token canvases rather than conventional left-to-right decoding.

For structured decision serving, questions are represented on the decision canvas and read in parallel.

Conceptually:

                  STATE + QUESTIONS
                         |
                         v
                 DiffusionGemma
                         |
                 decision canvas
       +-----------------+------------------+
       |                 |                  |
    operation          risk            blast_radius
       |                 |                  |
       v                 v                  v
   distribution      distribution       distribution
       |                 |                  |
       +-----------------+------------------+
                         |
                         v
                 Typed DecisionVector

This is the core reason a single model can evaluate many decision fields with low latency.

Recommended serving path

The checkpoint was validated with the djev-spark structured-read serving pattern:

vLLM structured-read engine
        |
        v
structured decision server (POST /v1/systemone)

The djev-spark server implements a Jev-compatible POST /v1/systemone API and also supports image inputs.

Validated serving stack (exact)

These are the components and flags this checkpoint's published evaluation numbers were measured with:

Component Version / value
vLLM 0.29.1rc1.dev347+gdee37d891 (structured-read build shipped inside the djev-spark image)
transformers (inside image) 5.17.0
djev-spark recipe https://github.com/mmastrac/djev-spark @ commit 1444f3e927f83ba508e5b28a4fd4fdd9ecd0976b
Hardware NVIDIA DGX Spark (GB10, 128 GB unified memory), CUDA 13.0
Attention backend TRITON_ATTN
Decision canvas 128 tokens
Measured latency (18 questions, 1 read) P50 144–149 ms, P95 155–159 ms

Equivalent vllm serve invocation (as run inside the validated container):

vllm serve /models/Geni-S1-Ops-26B-A4B-NVFP4 \
  --served-model-name Geni-S1-Ops \
  --max-num-seqs 8 \
  --max-model-len 4096 \
  --attention-backend TRITON_ATTN \
  --gpu-memory-utilization 0.40 \
  --kv-cache-memory 2147483648 \
  --max-logprobs 32 \
  --enable-prefix-caching \
  --diffusion-config '{"canvas_length": 128}' \
  --override-generation-config '{"max_new_tokens": null}' \
  --async-scheduling

The structured decision server (started by the djev-spark entrypoint) then exposes POST /v1/systemone (default port 8011) in front of the vLLM engine (default port 8010).

Notes:

  • Structured reads (diffusion_seed_canvas / read-only denoise logprobs) depend on this vLLM build line until equivalent support is fully upstream; a stock vLLM release may refuse the request shape or the model's LoRA interface (DiffusionGemmaForConditionalGeneration does not support LoRA yet at the time of validation). This checkpoint is fully merged and quantized precisely so the serving path needs no adapter loading.
  • processor_config.json must be present next to the weights (the image processor config is required by the serving stack).

Example: operational decision request 

curl -s http://localhost:8011/v1/systemone \
  -H 'content-type: application/json' \
  -d '{
    "model": "Geni-S1-Ops",
    "instructions": "Classify operational semantics using the supplied state. Risk depends on environment, redundancy, service criticality, blast radius, reversibility, and data/security impact. Use UNKNOWN when the supplied state is insufficient.",
    "state": {
      "command": "kubectl scale deployment payments --replicas=0",
      "platform": "kubernetes",
      "environment": "production",
      "current_replicas": 3,
      "service_tier": "critical"
    },
    "questions": {
      "operation": {
        "type": "choice",
        "instructions": "What operation is being performed?",
        "criteria": {
          "OBSERVE": null,
          "CREATE": null,
          "MODIFY": null,
          "DELETE": null,
          "EXECUTE": null,
          "UNKNOWN": null
        }
      },
      "risk": {
        "type": "choice",
        "instructions": "What is the operational risk?",
        "criteria": {
          "LOW": null,
          "MEDIUM": null,
          "HIGH": null,
          "CRITICAL": null,
          "UNKNOWN": null
        }
      },
      "blast_radius": {
        "type": "choice",
        "instructions": "What is the most likely blast radius?",
        "criteria": {
          "OBJECT": null,
          "SERVICE": null,
          "HOST": null,
          "CLUSTER": null,
          "ENVIRONMENT": null,
          "UNKNOWN": null
        }
      },
      "reversible": {
        "type": "choice",
        "instructions": "How reversible is the operation?",
        "criteria": {
          "FULL": null,
          "PARTIAL": null,
          "NONE": null,
          "UNKNOWN": null
        }
      }
    },
    "samples": 1,
    "steps": 1,
    "think": 0,
    "sequential": false
  }'

Application code should map returned values into strongly typed enums / schemas before policy evaluation.

Example: image input

The structured server can receive one or more images as multipart form data.

curl -s http://localhost:8011/v1/systemone \
  -F 'request={
    "model":"Geni-S1-Ops",
    "state":{
      "goal":"Identify whether the Restart button is visible"
    },
    "questions":{
      "target_visible":{
        "type":"choice",
        "instructions":"Is the requested UI target visible?",
        "criteria":{
          "YES":null,
          "NO":null,
          "UNKNOWN":null
        }
      }
    }
  }' \
  -F 'screen=@screenshot.png'

S1-Ops has preserved visual grounding, but GUI action selection is not yet a trained capability.

Production evaluation

The final checkpoint was evaluated after tied-weight-safe merge, ModelOpt NVFP4 quantization, and real serving.

The evaluation sets below are internal fresh blind sets designed for this project. They are not public standard benchmarks.

Representative blind set

Metric BF16 NVFP4 served
Macro-F1 0.815 0.852
UNKNOWN recall 0.899 0.993
CRITICAL recall 0.800 (n=10) 0.500 (n=10)
ECE ~0.012 ~0.029

Quantization note

On the small representative CRITICAL slice, post-quantization recall shifted from 8/10 to 5/10.

All five misses were adjacent:

CRITICAL -> HIGH

There were no observed:

CRITICAL -> MEDIUM
CRITICAL -> LOW

errors in this slice.

The support is small (n=10), so this boundary should be monitored on larger future blind sets.

Safety-stress blind set

Metric BF16 NVFP4 served
Macro-F1 0.664 0.666
UNKNOWN recall 0.657 0.819
CRITICAL recall 1.000 (35/35) 1.000 (35/35)
ECE 0.033 0.034

Observed safety-error geometry on the stress evaluation was predominantly conservative:

  • zero observed CRITICAL -> LOW/MEDIUM,
  • zero observed data-loss misses,
  • one destructive miss,
  • three availability misses,
  • major risk confusions were predominantly HIGH -> CRITICAL and MEDIUM -> HIGH,
  • UNKNOWN false-positive rate was approximately 3.3%.

This means much of the remaining macro-F1 loss on the stress set came from over-escalation, not dangerous risk under-calling.

Latency

Measured served NVFP4 latency for the operational structured-read path:

Metric Latency
P50 144–149 ms
P95 155–159 ms

For comparison, the same adapted model evaluated through an unoptimized in-process Transformers path was approximately ~1.1 s; that number should not be used as the serving benchmark.

Latency will vary with:

  • hardware,
  • number of questions,
  • canvas settings,
  • image inputs,
  • samples,
  • denoise steps,
  • context length,
  • serving engine and kernel version.

Model lineage 

google/diffusiongemma-26B-A4B-it
              |
              v
     operational fine-tune
              |
              v
     tied-weight-safe merge
              |
              v
  validation consistency gate
              |
              v
 NVIDIA ModelOpt NVFP4 PTQ
              |
              v
       djev/vLLM serving
              |
              v
        Geni-S1-Ops

Tied-weight merge note

DiffusionGemma contains tied/aliased encoder and decoder parameters.

During deployment work, hundreds of decoder tensors were runtime aliases of encoder tensors. A naïve verification path with adapters still active caused deltas to be effectively double-applied and failed the consistency gate.

The deployment pipeline therefore used a tied-weight-aware process:

identify aliases
      |
untie / materialize per path
      |
merge adapter exactly once per path
      |
disable adapters
      |
verify
      |
save using original shard/index structure
      |
ModelOpt quantization

If reproducing this model from the training adapter, do not assume a generic merge path is sufficient without validating tied-weight behavior.

Quantization

The public serving checkpoint is intended to be the NVFP4 artifact, not the raw BF16 training checkpoint.

The deployment conversion used NVIDIA ModelOpt's DiffusionGemma-oriented NVFP4 workflow and operational decision prompts representative of the real inference distribution as PTQ calibration inputs.

After quantization, the checkpoint was re-evaluated for:

  • macro-F1,
  • UNKNOWN recall,
  • CRITICAL recall,
  • calibration,
  • safety error direction,
  • serving latency.

Quantization therefore forms part of the validated model artifact, rather than being treated as a purely mechanical post-processing step.

Recommended application architecture

Geni-S1-Ops should not directly authorize infrastructure changes.

                  Operational state
                         |
                         v
                  Geni-S1-Ops
                         |
                Typed decisions
                         |
             confidence / UNKNOWN
                         |
                         v
             Deterministic policy
        authorization / approval / RBAC
                         |
                         v
                  Action Gateway
                         |
                         v
                   Environment

Example:

IF environment == PROD
AND risk IN {HIGH, CRITICAL}
AND destructive == YES
THEN
    REQUIRE enhanced validation / approval

The post-quantization representative evaluation observed some adjacent CRITICAL -> HIGH movement. For high-impact production operations, policy should therefore avoid making the safety boundary depend on a single distinction between HIGH and CRITICAL.

Intended uses

Good fits include:

  • command classification,
  • operational risk assessment,
  • blast-radius estimation,
  • change semantics,
  • incident / alert typed decisioning,
  • fast pre-policy classification,
  • automation confidence / abstention signals,
  • high-frequency System-1 decisions before a larger reasoning model,
  • multimodal operational screen interpretation,
  • research on typed probabilistic decision models.

A common architecture is:

Geni-S1-Ops
     |
     +--> confident typed decision --> policy/action
     |
     +--> UNKNOWN / uncertain --> larger System-2 model or human

Out-of-scope / not validated

This release should not be assumed to provide:

  • unrestricted autonomous command execution,
  • final authorization decisions,
  • production-safe behavior outside the evaluated ontology without testing,
  • a complete computer-use action policy,
  • browser / Windows multi-step task completion,
  • guaranteed calibrated probabilities on arbitrary domains,
  • guaranteed safety for unseen infrastructure environments,
  • a substitute for deterministic parsing when exact structured facts are available.

If Kubernetes / cloud / OS APIs already return an exact structured fact, parse it deterministically rather than asking the model to infer it.

Reproducibility metadata 

base checkpoint:            google/diffusiongemma-26B-A4B-it (BF16, pulled 2026-09-21)
training adapter sha256:    e3ce1837c3d2edf3acac88e3d5ba2891a511fc518d4a20a0d5b5f00f663e595a  (adapter_model.safetensors, 88 MB)
merged BF16 shard[1] sha256: ed1bdac2da6c69dd2bfe7baad0cad2481cdbd61d9c68e1dbe43bea65989f2d31
merged BF16 shard[11] sha256: a3975c358897ac3ec8526af58dc48d1f255fadada2e167c46b20fa421c948c98
NVFP4 shard 1 sha256:       26ad0fcfbe05a693d3b2278f98e11d8db2ba7a7e6214806973af522c6f9b8446
NVFP4 shard 2 sha256:       50214dc9b60e9eed5b8ce8a0b21fea335af6e6c79e90013db59569133b10b96e
ModelOpt version:           nvidia-modelopt 0.46.1
PTQ recipe:                 model_type/diffusion_gemma/ptq/nvfp4_experts_only (NVFP4 W4A4 experts; attention/dense MLP/self-conditioning BF16; FP8 KV cast; max calibration, 256 samples)
vLLM version / commit:      0.29.1rc1.dev347+gdee37d891 (djev-spark image)
djev-spark commit:          1444f3e927f83ba508e5b28a4fd4fdd9ecd0976b
training dataset:           internal operational decision corpus (1,283 states, ~23K labeled decisions) - not published
PTQ calibration dataset:    256 rendered decision prompts from the training distribution - not published
evaluation datasets:        internal fresh blind sets (representative-200, safety-stress-100) - not published; metric summaries in evals/
schema version:             SYSTEM1_OPERATIONAL_V1 (18 model fields)

Recommended versioning:

model:       Geni-S1-Ops v1.0
schema:      SYSTEM1_OPERATIONAL_V1
precision:   NVFP4

Suggested repository contents 

.
├── README.md
├── LICENSE
├── config.json
├── processor_config.json
├── tokenizer.json
├── tokenizer_config.json
├── model.safetensors.index.json
├── model-*.safetensors
│
├── schemas/
│   └── system1_operational_v1.json
│
├── examples/
│   ├── operational_request.json
│   ├── curl_operational.sh
│   └── curl_image.sh
│
└── evals/
    ├── representative_metrics.json
    ├── stress_metrics.json
    └── screenspot_probe.json

A separate research repository may optionally contain the raw LoRA adapter and training recipe.

Upstream references

License

The upstream google/diffusiongemma-26B-A4B-it model is published under the Apache License 2.0.

This repository should include the applicable license and preserve upstream attribution. Users should review the upstream model card, license, and usage/safety guidance before deployment.

Citation 

@misc{geni_s1_ops,
  title        = {Geni-S1-Ops: A Multimodal System-1 Typed Decision Model for IT Operations},
  author       = {Microland},
  year         = {2026},
  howpublished = {Hugging Face model release}
}

Acknowledgements

Geni-S1-Ops builds on:

  • DiffusionGemma by Google DeepMind,
  • NVIDIA ModelOpt for deployment quantization,
  • vLLM structured-read work,
  • the djev-spark reference implementation for DiffusionGemma structured decisions.

Release status

Geni-S1-Ops: production-path model frozen.

Validated capabilities:

typed operational decisions       YES
explicit UNKNOWN behavior         YES
multimodal image input            YES
UI visual grounding preserved     YES
NVFP4 structured serving          YES
Downloads last month
28
Safetensors
Model size
14B params
Tensor type
BF16
·
U8
·
Inference Providers NEW
Image-Text-to-Text
This model isn't deployed by any Inference Provider. 🙋 Ask for provider support

Model tree for microlandltd/Geni-S1-Ops-26B-A4B-NVFP4

Base model

google/diffusiongemma-26B-A4B-it
Quantized
(35)
this model