Model reference · open weights
fibo-scene-analyzer is an open-weight language model from briaai. fibo-scene-analyzer (BF16) weighs 71.9 GB; the smallest configuration that runs it is A100 80 GB.
For self-hosting, compare this build's requirements below with the GPU you plan to rent.
What it is
| Released by | briaai |
|---|---|
| Released | 2026-09-10 |
| Parameters | 36.0B |
| VRAM | 71.9 GB for the weights |
What it runs on
| Card | Requests at once | Context max | Memory | |
|---|---|---|---|---|
| 8K each | 32K each | |||
| RTX 3060 12 GB … L40S 48 GB 6 smaller cards | ||||
| A100 80 GB | 12 | 4 | 175K | 78.2 GB |
| H100 80 GB | 78.1 GB | |||
| RTX PRO 6000 Blackwell 96 GB | 43 | 16 | all 256K | 93.8 GB |
| DGX Spark (GB10) 128 GB unified | 89 | 33 | all 256K | 107 GB |
| H200 141 GB | 192 | 71 | all 256K | 138 GB |
| B200 180 GB | 314 | 116 | all 256K | 176 GB |
| 2× L40S 48 GB tensor parallel | 37 | 13 | all 256K | 44.0 GB a card |
| 4× RTX 4090 24 GB tensor parallel | 24 | 7 | all 256K | 23.4 GB a card |
| 4× RTX 3090 24 GB tensor parallel | 25 | 8 | all 256K | 23.4 GB a card |
| 4× RTX 5090 32 GB tensor parallel | 91 | 28 | all 256K | 31.0 GB a card |
| 2× H100 80 GB tensor parallel | 224 | 83 | all 256K | 78.1 GB a card |
| 2× A100 80 GB tensor parallel | 268 | 99 | all 256K | 78.2 GB a card |
| 2× RTX PRO 6000 Blackwell 96 GB tensor parallel | 330 | 122 | all 256K | 93.8 GB a card |
| Requests at once | 8K tokens each | 32K tokens each |
|---|---|---|
| 1 | 74.7 GB | 75.2 GB |
| 5 | 75.9 GB | 78.4 GB |
| 8 | 76.8 GB | 80.8 GB |
| 16 | 79.1 GB | 87.2 GB |
| 32 | 83.9 GB | 100.0 GB |
| 64 | 93.4 GB | 126 GB |
One card, with vLLM's small-card settings.
Builds
| Build | Params | Precision | Weights | Smallest setup |
|---|---|---|---|---|
| fibo-scene-analyzer (above) ↗ | 36.0B | BF16 | 71.9 GB | A100 80 GB |
| fibo-scene-analyzer-gguf ↗ 2 builds: Q4_K_M 21.5 GB … Q8_0 36.9 GB |
GGUF | 21.5 GB | 2× RTX 3060 12 GB |
From the model card
FIBO Scene Analyzer [dev] was developed to cover a wide range of image understanding tasks using Bria's scene description format. A scene description holds a general description of the image (type, style, lighting, composition, color palette and more) and a tree of objects. Each object has a name, a description, its geometry (bounding boxes, polygon masks, body keypoints), its colors, its relationships to other objects and fields for its kind: people, animals, text and other objects.
The same model also does grounding (detection, masks, and body keypoints for a named target, or for all objects), OCR with line boxes, and text-to-description tasks: it expands a short prompt to a full scene description, and it refines or edits a scene description from an instruction.
We built FIBO Scene Analyzer from Qwen3.6-35B-A3B via multi-stage SFT on a custom synthetic dataset, then GRPO reinforcement learning with task-specific rewards, then a final short SFT stage. For synthetic data, we developed a 12-step workflow that combines computer vision tools, general and specialist models to extract all possible structured information from the images.
| Task | Input | Prompt text | Answer |
|---|---|---|---|
caption | image | `` | SceneDescription |
detect | image, optional target | `` or TARGET | SceneObjectList: names, kinds, boxes |
mask | image, optional target | `` or TARGET | as detect, with polygon masks |
keypoints | image, optional target | `` or TARGET | people with boxes and named keypoints |
ocr | image | `` | text objects: language, lines, line boxes |
describe | image, object name | NAME | one object with all its fields |
expand | prompt, aspect ratio | \nAR\nPROMPT | SceneDescription of a new image |
expand_object | object name, optional scene description | NAME, or with \nSCENE_JSON after the name | one object with all its fields |
refine | instruction, scene description JSON | INSTRUCTION\nSCENE_JSON | the changed SceneDescription |
edit | 1-5 images, instruction | \nAR\nINSTRUCTION | SceneDescription of the edited image |
AR is the width divided by the height, rounded to two decimals.
With a scene description (scene_contexts in generate()), expand_object describes
the object so that it fits the scene, with relationships to the objects of the scene. The
scene must not contain the object itself.
SCENE_JSON is compacted JSON with coordinates and colors as
tokens. prompt_json() in scene_analyzer.py writes a SceneDescription in this form, also
after post_process().
For the grounding tasks, a named target that is not in the image gives an empty list.
Without a target, detect and mask return every object; clothing, footwear and
accessories are separate targets named "ITEM on PERSON".
| Detail level | Content |
|---|---|
general | the general block only, without objects |
short | a flat list of objects, with name, kind, description, location, position, relative size and text lines |
long | as short, plus colors, details, relationships and the fields of each kind |
full | the object tree with bounding boxes, relative distance, and body keypoints |
full_mask | as full, with a polygon mask for most of the objects |
expand, refine and edit accept general, short, long and full.
expand_object accepts short, long, full and full_mask.
Download the code files of this repository, then:
from PIL import Image
from scene_analyzer import SceneAnalyzerModel, SceneAnalyzerTask, DetailLevel
model = SceneAnalyzerModel("briaai/fibo-scene-analyzer") # Transformers, device_map="auto"
image = Image.open("photo.jpg").convert("RGB")
[description] = model.generate([image], SceneAnalyzerTask.CAPTION, detail_level=DetailLevel.FULL, num_samples=3)
description.post_process() # coordinate and color tokens to numbers
print(description.general.description)
for object in description.objects or []:
print(object.kind, object.name, object.bounding_boxes)
[people] = model.generate([image], SceneAnalyzerTask.DETECT, text_inputs=["person"])
[text] = model.generate([image], SceneAnalyzerTask.OCR)
To render an answer as an HTML page with the geometry drawn on the image:
from caption_visualizer import CaptionVisualizer
CaptionVisualizer().save("description.html", image, description)
To make it easier to work with the model and get the best results, we provide harness classes
based on the Pydantic scene description format.
The three harnesses have the same SceneAnalyzerModel.generate() interface and the same
task logic; only the engine differs.
| File | Engine | Use it for |
|---|---|---|
scene_analyzer.py | Hugging Face Transformers | the smallest set of dependencies |
scene_analyzer_vllm.py | vLLM, in the same process | batch processing; the output is constrained to the schema |
scene_analyzer_server.py | an OpenAI-compatible server | a model served separately (vLLM, SGLang) |
What each harness does:
ValueError.num_samples answers and returns the best valid one. A scene description
with the most objects wins; for grounding tasks, the most confident answer wins.
An input without a valid answer is sampled again (retries), and
None is returned if all attempts fail.num_iterations, it runs revision rounds: the model sees its answer and adds the
objects that it missed. This works for `` and the whole-image grounding tasks.from scene_analyzer_vllm import SceneAnalyzerModel
model = SceneAnalyzerModel("briaai/fibo-scene-analyzer", gpu_memory_utilization=0.9)
descriptions = model.generate(images, SceneAnQuoted from the model card on Hugging Face. The full card is behind the Hugging Face link above.