English | ็ฎ€ไฝ“ไธญๆ–‡

Agnes AI logo

Agnes 2.5 Pro Theta

Conversational reasoning ยท Scientific problem solving ยท Coding ยท Visual understanding

Benchmarks ยท Model information ยท Quickstart ยท License

Agnes 2.5 Pro Theta is a multimodal mixture-of-experts checkpoint distributed with its model implementation, tokenizer, chat template, and image/video processors. This release provides BF16 weights for local inference through Transformers.

The supplied evaluation snapshot covers eight benchmarks, with 92.9 on GPQA Diamond, 90.5 on LiveCodeBench v6, and 84.7 on AA-LCR. The package has approximately 187.8B total parameters and a configured context limit of 262,144 tokens.

Benchmarks

Agnes 2.5 Pro Theta benchmark comparison

Scores are percentages; higher is better. The table follows the figure's display precision of one decimal place. Bold indicates the highest reported value in each row of this supplied comparison.

Benchmark Agnes 2.5 Pro Theta Nemotron 3.5 Super VL 120B Qwen3.8-27B GLM-5.3-Flash DeepSeek-V4.1-Flash-1017
IFBench 82.6 70.9 80.1 64.4 76.3
AA-LCR 84.7 68.6 72.6 76.7 80.4
GPQA Diamond 92.9 89.5 88.9 92.2 92.8
SciCode 56.0 47.1 47.9 53.4 57.6
LiveCodeBench v6 90.5 88.2 90.3 80.6 89.7
SWE-bench Pro 64.1 51.8 61.7 59.7 โ€”
HLE-Diamond 16.8 8.8 15.3 18.2 25.3
GDP.pdf 16.2 8.0 16.4 15.4 17.2
  • AA-LCR: the supplied Theta result is labeled v1.1.
  • SciCode: the supplied Theta result is labeled v1.0.1 and uses subproblem-level scoring.
  • SWE-bench Pro: โ€œโ€”โ€ means not reported in the supplied figure.

Download scores as JSON ยท Download scores as CSV. The data files retain the full numeric precision available in the SVG metadata and its comparator source links.

Model Information

This package registers 52 text decoder layers.

Property Value
Publisher Agnes AI
Model name Agnes 2.5 Pro Theta
Model class Multimodal mixture-of-experts model
Parameters 187,763,545,616 (~187.8B total)
Registered text decoder layers 52 layers
Experts 512 routed experts per MoE block; top-10 routing; shared expert branch
Configured context limit 262,144 tokens
Input pathways Text, images, and video frames via the supplied processors
Output Text
Languages highlighted English, Chinese
Weight precision BF16
Weight packaging 105 Safetensors shards with an index
Weight tensor payload 375.5 GB (~349.7 GiB), excluding file headers
Implementation Custom Transformers code; trust_remote_code=True required
License Apache License 2.0

The context value is a configuration limit, not a claim that every context length or modality combination has been benchmarked. Available sequence length also depends on runtime memory and workload.

Hardware Requirements

The unquantized weight payload alone is approximately 349.7 GiB. Plan additional memory for loading, activations, caches, and visual inputs.

  • GPU memory: aggregate memory must exceed the weight payload plus runtime overhead for fully resident inference. A system with 4 ร— H200-class GPUs is a practical capacity starting point, not a measured throughput or maximum-context guarantee.
  • Storage: allow at least 400 GB for a single local copy; downloading, caching, or repacking can require additional space.
  • Host memory: provide ample RAM for loading. The implementation contains a large lexical lookup table; loading or offloading it can add substantial memory and I/O overhead.
  • Context and images: begin with short inputs and modest generation lengths, then increase within the available memory budget.

Quickstart

Environment

The configuration, custom model classes, tokenizer, and image processor were checked in an environment with PyTorch 2.14.1+cu130, Transformers 5.19.0, Accelerate 1.15.0, and Safetensors 0.8.0. These checks cover model construction and input preparation, not a full end-to-end generation qualification.

Install a CUDA-enabled PyTorch build appropriate for your machine, then install the Python dependencies:

pip install "transformers==5.19.0" "accelerate==1.15.0" "safetensors==0.8.0" pillow torchvision

The examples below load a local copy of this repository. Set MODEL_PATH to its location. Inspect the custom Python files before enabling trust_remote_code=True.

Text generation

import os
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_path = os.environ.get("MODEL_PATH", "./agnes-2.5-pro-theta")

tokenizer = AutoTokenizer.from_pretrained(
    model_path,
    trust_remote_code=True,
)
model = AutoModelForCausalLM.from_pretrained(
    model_path,
    trust_remote_code=True,
    dtype=torch.bfloat16,
    device_map="auto",
    attn_implementation="eager",
    experts_implementation="grouped_mm",
).eval()

messages = [
    {"role": "user", "content": "Explain gradient descent and show a small Python example."}
]
inputs = tokenizer.apply_chat_template(
    messages,
    tokenize=True,
    add_generation_prompt=True,
    return_dict=True,
    return_tensors="pt",
    reasoning_effort="low",
).to(model.device)

with torch.inference_mode():
    output_ids = model.generate(**inputs, max_new_tokens=512)

new_tokens = output_ids[:, inputs["input_ids"].shape[-1]:]
print(tokenizer.batch_decode(new_tokens, skip_special_tokens=True)[0])

device_map="auto" distributes modules according to available memory; it is not tensor parallelism. The example uses eager attention and grouped MoE execution. Optimized serving-engine compatibility and performance must be checked for this custom implementation before deployment.

Image understanding

With the same loaded model, use the supplied processor to prepare image inputs:

from PIL import Image
from transformers import AutoProcessor

processor = AutoProcessor.from_pretrained(model_path, trust_remote_code=True)
image = Image.open("example.png").convert("RGB")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "image": image},
            {"type": "text", "text": "Describe this image and explain the key details."},
        ],
    }
]
inputs = processor.apply_chat_template(
    messages,
    tokenize=True,
    add_generation_prompt=True,
    return_dict=True,
    return_tensors="pt",
    reasoning_effort="low",
).to(model.device)

with torch.inference_mode():
    output_ids = model.generate(**inputs, max_new_tokens=512)

new_tokens = output_ids[:, inputs["input_ids"].shape[-1]:]
print(processor.batch_decode(new_tokens, skip_special_tokens=True)[0])

Generation Settings

Defaults shipped in generation_config.json:

Setting Value
do_sample true
temperature 1.0
top_p 0.95
top_k 20

Set max_new_tokens explicitly for the application. It is a generation budget and must fit within the total context and memory limits. The supplied chat template supports reasoning_effort and enable_thinking; examples use reasoning_effort="low".

Limitations

The scores above summarize a publisher-provided chart, not a reproducible evaluation bundle. Exact prompts, sampling settings, token budgets, agent scaffolds, and raw run logs are not included. Visual and video processing pathways are present, but the listed scores do not establish comprehensive image/video performance or long-context reliability. Generated answers and code can contain errors; validate outputs before consequential use.

License

This release is distributed under the Apache License 2.0, as specified by the publisher.

Citation

@misc{agnes25protheta,
  title  = {Agnes 2.5 Pro Theta},
  author = {{Agnes AI}},
  year   = {2026},
  note   = {BF16 model checkpoint and publisher-supplied evaluation snapshot}
}
Downloads last month
130
Safetensors
Model size
188B params
Tensor type
BF16
ยท
I64
ยท
Inference Providers NEW
This model isn't deployed by any Inference Provider. ๐Ÿ™‹ Ask for provider support

Model tree for Agnes-AI/Agnes-2.5-Pro-Theta

Quantizations
2 models