Bongard-mini

Official website

Bongard-mini is an open-weight System One model for machine intuition and Jev-like judgment, built on the T5 encoder–decoder architecture of T5Gemma 2 4B-4B. Give it text, structured data or images, along with questions and candidate answers or actions. It returns a probability distribution for each question without generating text.

Read once. Judge in parallel.

Try the live demo · Get started locally · Code & runtime · Design · Benchmarks · Examples

In the live demo's Playground, choose an example, edit the Input and the questions under Questions & settings, then click Run to get new probabilities. The demo runs on Hugging Face ZeroGPU: anonymous quota is limited, and signing in provides more quota. For local execution, use the quick start below. The game GIFs below and the examples on the website are recorded outputs; use the live demo to try your own input.

Bongard-mini is trained on judgments, semantic relationships and action outcomes. The same model can read a customer conversation, compare an invoice with an order, or judge an agent's next action.

Game recordings

2048 — 4096 tile, 55,140 final score	Tetris — consecutive line clears
Othello — 13–0 win against a positional opponent	Snake — grows to 32 cells on an 8×8 board

These selected gameplay recordings show Bongard-mini choosing actions from candidate lists. For board games, the engine supplies legal moves and their computed features; 2048 and Tetris also include engine ratings of moves. A short instruction states the strategy, and the model selects each action. The scores describe these selected recordings with the supplied engine features.

Doom — Defend the Center

The model receives a text description of the scene every 0.2 seconds and chooses turn_left, turn_right or fire. Across 32 episodes capped at 30 seconds, it averaged 10.25 kills, with a best of 20. The GIF shows an excerpt, with probabilities beside the action.

Intuition is learned

An experienced player sees a promising move. A reader catches irony. Such judgments draw on learned relationships, often before the person can explain each step. Their value extends beyond speed: a whole pattern can carry meaning that is hard to express as a list of reasons.

Bongard treats this form of judgment as an independent capability to design and train.

All three stages are complete. They update 7.09 billion trainable parameters, including the text backbone, multimodal projector and judgment head. The vision tower stays frozen. Each stage ran on one GPU: a B200 for stages 1 and 2, and a B300 for stage 3.

One reading, many decisions

Bongard-mini uses the T5 encoder–decoder structure of T5Gemma 2 4B-4B, with 7.51 billion total parameters. The encoder reads the evidence in both directions, with the question instructions in view. Separate decoder branches share that evidence. A trained head scores each candidate from its name and description. The runtime reads the state once and processes questions in groups of up to eight.

This structure serves a concrete purpose. A later clause can change the meaning of an earlier one; a log entry can explain an earlier failure. Bidirectional encoding lets those facts shape each other's representation before the model makes several judgments about the situation.

A wrapper changes the interface. Bongard trains the judgment.

OpenJev's default implementation wraps pretrained DiffusionGemma and reads answer-token probabilities. Kev trains LoRA adapters and a pointer head on Qwen, and reuses a causal state cache across questions. Bongard develops a shared, bidirectional evidence representation through full-model training on judgments, semantic relationships and action outcomes.

Jev is a trained, closed System One model. Bongard provides an open T5 route to the same class of judgments. The results below show how their strengths differ across tasks and measures. Full-model training costs more than adapter training; Bongard uses it to shape both the evidence representation and the judgment function.

Quick start

Use Python 3.12 or later. Install the runtime from GitHub and download the complete model bundle:

git clone --branch main --depth 1 https://github.com/AgentBull/bongard.git
cd bongard
python -m pip install .
hf download AgentBull/bongard-mini --local-dir bongard-mini

The examples below use CUDA. Use device="mps" on Apple Silicon or device="cpu" for CPU execution; the CLI accepts the same values with --device. The runtime loads the BF16 weights, with additional memory needed for the input and candidate descriptions.

Python: three questions, one state

import json
from bongard.inference import Predictor

predictor = Predictor.load(
    "bongard-mini",
    device="cuda",
    temperatures="bongard-mini/temperatures.json",
)

request = {
    "state": {
        "message": "My order arrived yesterday with a broken screen. Please replace it.",
        "policy": "Replace items damaged on delivery if reported within 14 days."
    },
    "questions": {
        "replace": {
            "type": "noul",
            "instructions": "Is this request eligible for a replacement under the policy?"
        },
        "route": {
            "type": "choice",
            "instructions": "Which team should handle this request?",
            "criteria": {
                "returns": "Damaged items, returns and replacements.",
                "billing": "Payment failures and invoice questions.",
                "sales": "New orders and product recommendations."
            }
        },
        "urgency": {
            "type": "score",
            "instructions": "How urgently does the customer need a response?",
            "criteria": [
                "Routine: can wait several days.",
                "Important: respond within one business day.",
                "Critical: immediate assistance is needed."
            ]
        }
    }
}

answers = predictor.predict(request)["answers"]
print(json.dumps(answers, indent=2))
print(answers["route"]["choice"])

Each entry in answers has the question ID you supplied:

Keep shared facts in state and put each decision in questions so the model can reuse its reading of the state. Use the supplied temperatures.json in both Python and the CLI to apply probability calibration. Loading only backbone/ with Transformers does not load the complete judgment model.

CLI and HTTP API

The GitHub repository includes a ready-to-run example request:

bongard predict --checkpoint bongard-mini --device cuda \
  --temperatures bongard-mini/temperatures.json \
  --request examples/request.json

To serve the model locally:

bongard serve --checkpoint bongard-mini --device cuda \
  --temperatures bongard-mini/temperatures.json \
  --host 127.0.0.1 --port 8000

In another terminal, from the same repository directory:

curl http://127.0.0.1:8000/v1/models

curl http://127.0.0.1:8000/v1/systemone \
  -H 'Content-Type: application/json' \
  --data-binary @examples/request.json

POST /v1/systemone uses the same request structure as Python and returns model, answers and usage. The API follows the System One wire format; usage.output_tokens is zero.

Using images

Add a top-level images array of base64 data URLs and refer to them as image 1, image 2, etc. PNG, JPEG and static WebP are supported. Local paths and remote URLs must be read and encoded first. For example, with your own package.png and the predictor loaded above:

import base64
from pathlib import Path

encoded = base64.b64encode(Path("package.png").read_bytes()).decode("ascii")
response = predictor.predict({
    "state": "A customer submitted a photo of their delivery.",
    "images": [f"data:image/png;base64,{encoded}"],
    "questions": {
        "damaged": {
            "type": "noul",
            "instructions": "Does image 1 show visible damage to the package?"
        }
    }
})
print(response["answers"]["damaged"]["noul"])

Benchmarks

DecisionBench was evaluated with its official runner on 2026-09-30. The other release evaluations below are from 2026-09-29. Measurements use one NVIDIA RTX PRO 6000 in BF16, with the splits and protocols stated below.

How to read these results: DecisionBench uses its own runner (jobs/run_system_one_http_eval.py at 9a6328e) against bongard serve at ea57853, through the System One HTTP contract, one request at a time. Serving limits were 262,144 tokens per request and 131,072 tokens per sequence, with up to 255 candidates. All 23,900 rows returned answers, with no errors or input truncation. The official run, summary and manifest are public. Of these rows, 2,941 have detected source-text overlap with training data; the remaining 20,959 score 77.73%.

An earlier custom-harness run remains in the evaluation repository. It sent 3,042 binary rows as two-option Choice questions, whereas the official runner sends Noul questions. Its scores belong to that earlier protocol and are not the headline result above.

JevBench scores cover its public questions. For typed-decisions, the gold is a teacher probability distribution, so its metrics measure agreement with that teacher. ImajevBench uses direct option scoring with an unknown option and averages all cyclic option orders.

DecisionBench comparison

Bongard-mini ranks fourth among the 61 systems in the full comparison. Reference scores are a 2026-09-29 snapshot of the DecisionBench leaderboard. Bongard-mini is our 2026-09-30 official-runner evaluation, with the serving limits and source-text overlap qualifications above. This table lists selected systems, rather than every leaderboard entry.

Bongard and Jev, by task and measure

Jev matches the teacher's top label more often on typed-decisions. Bongard's full distributions are closer to the teacher's under KL and Brier. These measures establish agreement with the teacher; calibration against observed outcomes needs a separate evaluation. Reference scores come from the dataset cards and leaderboards on 2026-09-29. Bongard's per-item predictions let you inspect the decisions behind the scores.

Inference speed

These are local inference measurements and exclude network overhead. The batched result comes from batched model evaluation; the supplied HTTP server processes one request at a time. Input length, candidate descriptions and hardware affect latency.

To evaluate your server on typed-decisions, use the included benchmark runner from the repository root while the server is running:

python benchmarks/typed_decisions.py \
  --endpoint http://127.0.0.1:8000 --output typed-results.json

Judgments across situations

These are selected test scenarios from typed-decisions, with Bongard's published predictions. Each row shows one question from a five-question request.

Evaluation notes

• Worked-answer checking: in the evaluated tasks, the model rarely rejected incorrect worked solutions.
• Calibration: use the supplied temperatures and evaluate probabilities on representative data. Refit calibration for a new deployment domain when needed.
• Candidate order: Choice probabilities can depend on option order. rotations=True in Predictor.load, or --rotations in the CLI, averages cyclic option orders at extra compute cost; it is off by default.

Model and license

This is the final three-stage Bongard-mini checkpoint. The public GitHub repository contains the inference runtime, HTTP server, supervised training loop and a typed-decisions benchmark runner. The training data, joint-embedding objectives, sandbox environments and full training recipes are not part of the code release.

Model weights are subject to the Gemma Terms of Use; see NOTICE. The runtime code is Apache-2.0.

Cite

@techreport{ding2026bongard,
  title  = {Bongard: Training Machine Intuition},
  author = {Ding, Li and Jin, Haidi and Ji, Chen},
  institution = {AgentBull Pte Ltd},
  year   = {2026}
}