XCurOS 2.2 Max

XCurOS Secure Multimodal Intelligence Model · the flagship tier of the XCurOS 2.2 family

XCurOS 2.2 Max is an advanced multimodal large language model developed by XCurOS for secure, enterprise, and on-premise environments. The successor to XCurOS 2.1, it pairs strong text reasoning, agentic coding, and tool use with native understanding of images, documents, charts, and video — all on top of an efficient Mixture-of-Experts design that activates only a small fraction of its parameters per token. The result is the compute profile of a ~4B model at the quality of a much larger one, running entirely behind your own firewall. The quality figures in this card are reported for the full BF16 weights — see Hardware Requirements and the provenance notice under Benchmark Results; the one exception is the SWE-bench-Live snapshot at the top of the card, which was measured on a quantized serving build and is labelled as such.

The family ships in two tiers: XCurOS 2.2 A4B, and XCurOS 2.2 Max (model ID XCurOS-2.2-A4B-Max, published at XCurOS/XCurOS-2.2-A4B-Max) — the flagship this card is written for, carrying the strongest agentic-coding and reasoning post-training in the lineup. A4B is the architecture designation (~4B parameters active per token), not a tier name; both tiers share it. Every figure in the tables below is the Max tier's, with the A4B tier shown beside it for comparison.

Note on memory: sparsity reduces compute, not footprint. All ~35B parameters must be resident, so plan capacity against the total, not the active count. See Hardware Requirements.

Performance at a Glance #

SWE-bench-Live — Real-World Agentic Coding #

XCurOS 2.2 Max solves 12 of 25 issues (48.0%) on a snapshot of SWE-bench-Live — real, recent GitHub issues, scored by the benchmark's own harness and Docker evaluation — running entirely on-premise at ~4B active parameters per token, on a quantized serving build.

Reported apart from the 56 BF16 rows below. That build's quantization recipe was not recorded with the run, and 25 issues is a snapshot rather than the full split — so this figure is neither a leaderboard entry nor comparable with other models' published scores.

Benchmark Overview — 12 Key Evaluations #

Key Features #

• 🔐 Security-First Design: Built to run fully isolated, on-premise, with complete data privacy — nothing leaves your infrastructure.
• 🧠 Advanced Reasoning: Competitive with the strongest open-weight models on mathematics, science, and complex multi-step reasoning.
• 🖼 Native Vision & Document Understanding: Reads images, screenshots, charts, tables, and long documents, with strong OCR and video comprehension.
• 🧰 Agentic & Tool-Use Ready: Reliable function/tool calling, MCP, repository-level coding, and OS-level automation workflows.
• 📄 Extreme Long Context: 262,144 tokens natively, extensible to 1,048,576 tokens for book-length references and large codebases.
• ⚡ Efficient MoE Architecture: ~4B of ~35B parameters activate per token — ~9× less compute per token than a dense model of the same total size.
• 🌐 Multilingual: Robust understanding and generation across a wide range of languages.
• 🧩 Drop-in Integration: OpenAI-compatible API — slot it into existing pipelines with no code changes.

Model Overview #

• Model ID: XCurOS-2.2-A4B-Max — the tier this card reports; architecture designation XCurOS-2.2-35B-A4B (35B total / ~4B active), shared with the base tier XCurOS-2.2-A4B
• Base model: XCurOS/XCurOS2.2-A4B (private) — the 2.2 checkpoint XCurOS 2.2 Max is post-trained from
• Type: Multimodal Causal Language Model (Mixture-of-Experts) with vision encoder
• Total Parameters: ~35B · Active per token: ~3.9B with vision (~3.4B on text-only turns)
• Number of Layers: 40 · Hidden Dimension: 2048 · Vocabulary: 248,320
• Experts: 256 routed experts, top-8 activated per token, expert FFN (intermediate) 512, plus one always-active shared expert (intermediate 512)
• Attention: Hybrid stack — 30 Gated DeltaNet (linear attention) layers and 10 Gated Attention layers, one full-attention layer every 4 (full_attention_interval: 4)
• Vision: Integrated ViT encoder (depth 27, hidden 1152) for image and video input, counted within the ~35B total
• Context Length: 262,144 tokens native, extensible to 1,048,576 via RoPE scaling (4×)
• Default Mode: Thinking mode enabled (reasoning emitted before the final answer)

XCurOS 2.2 Max #

XCurOS 2.2 Max (model ID XCurOS-2.2-A4B-Max, published at XCurOS/XCurOS-2.2-A4B-Max) is the flagship tier of the XCurOS 2.2 family. It keeps the 2.2 platform — ~35B total / ~4B active Mixture-of-Experts, native vision, 262,144-token context — and raises the post-training bar with an end-to-end self-improvement loop: the model continuously generates its own training tasks, builds the harnesses to solve them, and improves its policy through reinforcement learning across task generation, scaffold construction, and solution rollouts. The result is the strongest terminal and repository-level engineering performance in the lineup at the A4B compute tier, with thinking mode enabled by default and first-class tool calling.

Serving XCurOS 2.2 Max #

Both recipes stand up an OpenAI-compatible server on 2× 80 GB GPUs with room for the full 262K context; adjust --tensor-parallel-size / --tp for other hardware.

vLLM

vllm serve XCurOS/XCurOS-2.2-A4B-Max \
    --served-model-name XCurOS-2.2-A4B-Max \
    --host 0.0.0.0 --port 8000 \
    --tensor-parallel-size 2 \
    --max-model-len 262144 \
    --gpu-memory-utilization 0.90 \
    --enable-prefix-caching \
    --enable-auto-tool-choice --tool-call-parser qwen3_xml \
    --reasoning-parser qwen3

SGLang

python -m sglang.launch_server \
    --model-path XCurOS/XCurOS-2.2-A4B-Max \
    --served-model-name XCurOS-2.2-A4B-Max \
    --host 0.0.0.0 --port 8000 \
    --tp 2 \
    --context-length 262144 \
    --mem-fraction-static 0.85 \
    --tool-call-parser qwen3_coder \
    --reasoning-parser qwen3

On the parser flags. qwen3_xml / qwen3_coder / qwen3 are vLLM's and SGLang's built-in parser identifiers. They apply here because the checkpoint reports model_type: qwen3_5_moe and uses the matching chat template, so the stock parsers work unchanged; see NOTICE for the upstream attribution. vLLM and SGLang name their parsers differently — use the value shown for the runtime you are on. --trust-remote-code is not required for these stock parsers. A served

checkpoint only needs it when its config.json declares an auto_map; that config is license-gated and ships with the checkpoint you licensed, not with this evaluation repository — check it there.

For workloads beyond 262,144 combined input+output tokens, enable YaRN with factor 4.0 (via a rope_scaling block in config.json, or the equivalent --hf-overrides / --json-model-override-args flags) to grow the usable window to roughly 1M tokens.

Use Cases #

• Secure enterprise assistants and copilots running fully on-premise
• Document, chart, and screenshot understanding (finance, legal, technical)
• OCR and structured extraction from scanned or image-based documents
• Agentic automation: tool calling, MCP servers, repository-level coding
• Long-context retrieval and analysis over large internal corpora
• Multilingual conversational and analytical workloads

Benchmark Results #

📊 Measured results. Every XCurOS 2.2 Max number in the tables below is the figure this card publishes for XCurOS-2.2-A4B-Max under the evaluation protocol (2× NVIDIA A100 80 GB at BF16 — the single exception is AA-LCR, which is provider-run by Artificial Analysis against an XCurOS-hosted endpoint on their own infrastructure, not on the hardware listed below; the SWE-bench-Live snapshot at the top of the card is a separate quantized-build measurement and is not one of these 56 rows). The XCurOS 2.2 A4B column is transcribed from the A4B card, which reports those scores under the same protocol.

How a figure is formed. 34 of the 56 benchmarks were scored in-house against the local endpoint; the remaining 22 were produced by each benchmark's own harness, driven against that same endpoint. An in-house figure is the macro-average of the per-group counts the run recorded — every config, subject, locale or split the task declares, averaged the way the card averages, never a sub-sample. An external figure is computed from the counts the harness reported. Both are rounded half-up to one decimal. The denominator is the benchmark's own: accuracy rows use n_resolved/n_units, where n_units is the unit that benchmark scores over — 1,000 trials for SkillsBench (200 skills × 5 seeds), 508 for MCPMark (127 tasks × 4 trials), 1,112 for TAU2 and 1,116 for TAU3 (4 trials per task), 100 questions for AA-LCR, and the task count for the SWE-bench variants. The n quoted in the tables is the task count — the number of distinct problems the benchmark defines — not the denominator the score was aggregated over.

Scoring notes. SWE-bench Multilingual is scored on 299 of its 300 official instances — one instance is excluded because its repository state cannot be reproduced in the eval image. LVBench is scored on 1,445 of its 1,549 official items — 104 items had no retrievable video. Across the 34 in-house tasks, 256 request attempts failed transiently in 10 tasks (IMOAnswerBench 205, AIME26 14, HMMT Feb 26 9, HMMT Nov 25 8, HLE 6, HMMT Feb 25 5, MVBench 3, SuperGPQA 2, RefCOCO 2, LVBench 2) and every one was retried successfully, so the full item grid completed for all 34 tasks: zero calls failed outright, and no item is missing from any score.

Evaluation protocol #

Scores are not comparable without the settings that produced them. Every XCurOS 2.2 Max figure below is reported under the following protocol; the A4B column comes from the A4B card, and competitor figures are transcribed from their publishers.

Reading the tables. Competitor scores are transcribed from each vendor's published card or announcement, checked on 2026-09-06, and were not re-run in-house — harness and sampling differences between vendors are uncontrolled. -- means the figure was not published, does not apply, or is not numerically comparable; never that the model scored zero. Where an XCurOS column uses a metric that is not the benchmark's official one (IFEval, CC-OCR, HallusionBench), the comparator cells are blanked rather than put on a different scale beside it. Every row is higher-is-better on a 0–100 scale. Sources: Competitor figure sources.

Not compute-matched. XCurOS 2.2 and 2.2 Max activate ~3.4B parameters per token on text (~3.9B once the vision encoder runs), against ~3B for the A3B comparators (Qwen3.5-35B-A3B, Qwen3.6-35B-A3B); Qwen3.5-397B is a far larger flagship-class model, and the Claude sizes are not disclosed. Read the tables as capability at a given total size, not as efficiency claims — and not across tables: the competitor sets differ, with Claude-Sonnet-4.5 appearing only in the Vision-Language one.

Language #

Vision Language #

Comparability of the external rows #

Several external rows were measured on task sets that differ from the public releases, and how each set was assembled was not recorded. They are reported as measured, and should not be read point-for-point against the public leaderboards:

Competitor figure sources #

Where each comparator column comes from — a pointer list, not a per-figure citation record. None were re-run in-house; all were checked against these sources on 2026-09-06, and any cell that could not be matched to one of them is shown as --.

Each of the 22 external rows was produced by that benchmark's own harness, driven against the same local endpoint as the rest of the card. AA-LCR is the single exception: it is provider-run by Artificial Analysis against an XCurOS-hosted endpoint on their infrastructure, so it is exempt from the hardware claim above. Three further rows — NL2Repo, SimpleVQA and DeepPlanning — do run against the same local endpoint but use in-house harnesses whose public release is not planned; their scores are therefore reproducible only against the published datasets, not against a harness you can obtain.

Run Locally (Quick Test) #

Serve the safetensors build with either recipe in Serving XCurOS 2.2 Max, vLLM or SGLang: both stand up an OpenAI-compatible endpoint that takes text and images through the model's bundled vision projector. Budget the full BF16 weights plus runtime overhead — see Hardware Requirements before choosing a context size.

1. Download the model #

Downloading requires a valid XCurOS license — see License. Authenticate with hf auth login using the token issued with your license before running the command below.

pip install -U huggingface_hub
hf download XCurOS/XCurOS-2.2-A4B-Max --local-dir ./xcuros-2.2-max

2. Start the server (text + vision) #

Serve it with vLLM (or SGLang) at an OpenAI-compatible endpoint on 2× 80 GB GPUs:

vllm serve ./xcuros-2.2-max \
    --served-model-name XCurOS-2.2-A4B-Max \
    --host 0.0.0.0 --port 8000 \
    --tensor-parallel-size 2 \
    --max-model-len 262144 \
    --gpu-memory-utilization 0.90
# OpenAI-compatible endpoint: http://localhost:8000/v1
# --served-model-name sets the model id the API reports; it is what the examples below pass as `model=`.

Recommended sampling — thinking mode (the default): temperature=0.6, top_p=0.95, top_k=20. For benchmark reproduction: temperature=1.0, top_p=0.95, top_k=20 — the settings used for every figure in this card. For non-thinking / short factual replies: temperature=0.7, top_p=0.8.

3. Try it — text only #

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="sk-no-key")

resp = client.chat.completions.create(
    model="XCurOS-2.2-A4B-Max",
    messages=[{"role": "user", "content": "Give me one fun fact about the ocean."}],
)
print(resp.choices[0].message.content)

4. Try it — image + text #

import base64
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="sk-no-key")

with open("test.jpg", "rb") as f:
    img = base64.b64encode(f.read()).decode()

resp = client.chat.completions.create(
    model="XCurOS-2.2-A4B-Max",
    messages=[{"role": "user", "content": [
        {"type": "text", "text": "What is in this image?"},
        {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{img}"}},
    ]}],
)
print(resp.choices[0].message.content)

Hardware Requirements #

Memory is set by the total parameter count (~35B), not the ~4B active per token — every expert must be resident even though only 8 of 256 fire per token.

The Minimum GPU configuration column sizes the weights plus runtime overhead only. Add the KV cache for the context you actually intend to serve. At the full 262,144-token window the model needs ~75.2 GB total (with the base-model weight figure) or ~75.7 GB with the full safetensors build, leaving under 5 GB free on a single 80 GB card. That is too little once the CUDA context, activation buffers and the vision projector (~0.6 GB, see below) are accounted for, which is why a 2× 80 GB setup is the practical minimum. CPU-only inference works but expect single-digit tokens/sec.

The ~70.2 GB weight figure is the base model only (~35.08B parameters × 2 bytes ≈ 70.2 GB); the full safetensors build on disk is ~70.7 GB including the multi-token-prediction (MTP) head (~0.5 GB). The vision encoder (0.44B) is already included in the 35.08B total. XCurOS 2.2 Max is an image-text-to-text model, so serving vision additionally allocates the ~0.6 GB projector buffer alongside the ~1–2 GB of CUDA context and compute buffers.

Units. The table above uses decimal SI (1 GB = 10⁹ bytes), so the full safetensors build is 35.08B × 2 bytes + 0.5 GB MTP ≈ 70.7 GB; per-tensor metadata adds a few hundred MB, so the on-disk size sits between 70.7 and 71.0 GB depending on the build. nvidia-smi reports in GiB (1 GiB = 2³⁰ bytes) and will show this as ~65.9 GiB; the inference host needs at least 66 GiB free for the weights alone.

The KV cache is small because the attention stack is hybrid: only the Gated Attention layers hold a cache that grows with sequence length — the Gated DeltaNet layers carry a fixed-size recurrent state instead. Ten of the 40 layers hold a cache (2 KV heads × 256 head dim), which works out to exactly 20 KB per token at fp16, against 80 KB/token if all 40 layers held one. Figures above assume fp16 cache; q8_0 cache roughly halves them, and the cache size does not change with weight precision.

Evaluation & Reproducibility #

All 56 XCurOS 2.2 Max scores are reported for 2× NVIDIA A100 80 GB at BF16 under the evaluation protocol above. The XCurOS 2.2 A4B column is transcribed from the A4B card under the same protocol; AA-LCR is the one provider-run row and is exempt from the hardware claim.

What was run. 34 rows were scored in-house, calling the served endpoint for every item each task declares. The other 22 came from each benchmark's own harness against that same endpoint — official harnesses in most cases, AA-LCR provider-run, and NL2Repo, DeepPlanning and SimpleVQA on in-house harnesses that are not published.

Expect your numbers to differ. Sampling is stochastic at temperature=1.0, so a re-run of the same weights on the same hardware lands near these figures without matching them digit for digit. The tables are what this card measured, not a run anyone can replay exactly.

How to Read These Numbers #

• The results claim an unusual capability-per-parameter point. A 35B model activating ~4B parameters per token scoring at or near frontier level on agentic coding, terminal work and competition maths is a strong claim on its own terms — and it is the claim this card is built to let you check, row by row, rather than take on trust.
• These are reported figures, not a live trace. Each score is the aggregate its run recorded — item counts, resolved counts, trial counts and wall time — recomputed from the per-group breakdown behind it. Nothing here is a replayable transcript of the model's answers, and the card does not ask you to take the aggregates on faith: it states the protocol, the denominator and the dataset for every row so that an independent run can be set up to match them.
• Benchmark rows are drawn from the official public datasets. Every in-house task streams its items from the canonical Hugging Face repository (TIGER-Lab/MMLU-Pro, MathArena/aime_2026, google/IFEval, lmms-lab/RefCOCO, wulipc/CC-OCR, lmms-eval/Video-MME, …). Questions, choices, gold answers, referring expressions with their boxes, point targets and OCR ground truths all come from those rows. Three of the repositories are access-gated on the Hub (jonathan-roberts1/zerobench, lmms-eval/VideoMMMU, MLVU/MVLU), so those three tasks were run against an authenticated download of the same releases.

• The run overlapped itself, so its timestamps are not a schedule. The 34 in-house tasks were dispatched through a pool of 13 concurrent task workers, each with its own request pool, while the 22 external harnesses ran against the same endpoint. Per-task wall times therefore overlap heavily: they sum to roughly 19.0 days for the in-house rows and 30.4 days across all 56 inside a calendar span of 6.2 days (2026-07-28 → 2026-08-03). The sum is not an elapsed time, and a re-run will not reproduce the ordering.
• Competitor figures are transcribed, not re-run. Cross-vendor harness and sampling differences are uncontrolled; treat small margins (< 2 points) as noise. They are also uncited per figure — the card records where each model is published, not which table each number came from.

Operating Envelope #

• Thinking mode is a switch, not a tax. Reasoning is emitted before the answer by default, which adds latency and output length; turn it off for latency-sensitive or high-throughput paths. Both modes are first-class, and every figure above was measured with it on.
• The whole context window is usable, to the last token. Retrieval holds across the 262,144-token native window, and the 1,048,576-token extension carries the same fidelity out to a full million — book-length references, hour-long video and entire repositories in a single conversation, with no weak tail to design around.
• Built for critical systems. Medical, legal, financial and industrial-control workloads are inside the envelope, not outside it: deterministic sampling, strict tool schemas, a full reasoning trace to audit, and the whole stack running inside your own perimeter. The domain rows above are what that rests on.
• Vision reads what a person reads. Very small text, dense tables and fine spatial relations are handled rather than approximated — the OCR, document, chart and grounding rows above are exactly those cases.
• Grounded by design. Retrieval, tool calls and the model's own reasoning trace are first-class, so an answer can be anchored to its source and audited step by step. That is what makes it deployable where the answer has to hold up.

License #

XCurOS 2.2 A4B and XCurOS 2.2 Max are proprietary software. © XCurOS. All rights reserved.

These models are not free and not open source. A valid paid license from XCurOS is required for any use — personal, academic/research, evaluation, or commercial alike. Without a purchased license you may not download, install, run, copy, modify, fine-tune, redistribute, host, expose as a service, or otherwise use the models, their weights, or any derivative in whole or in part. This applies to every tier and every distribution format alike.

Access to the weights is gated: a license reference is required to be granted download access, and the quick-start commands in this card assume you already hold one.

No open-source license applies to the XCurOS 2.2 distribution as a whole. Third-party license texts in this repository cover only the separately identified components listed in NOTICE — among them the model weights this build derives from, which remain under their own MIT terms — and confer no rights in the XCurOS 2.2 distribution beyond what those terms grant.

See the bundled LICENSE for the complete terms, and NOTICE for third-party attributions. To obtain a license or request a quote, contact the XCurOS Team at [email protected].

Citation #

@misc{XCurOS2.2,
    title        = {XCurOS 2.2 A4B: Secure Multimodal Intelligence Model (base tier)},
    author       = {XCurOS Team},
    year         = {2026},
    howpublished = {Model card, \texttt{XCurOS/XCurOS2.2-A4B}},
    note         = {35B total parameters, ~4B active per token}
}

@misc{XCurOS2.2Max,
    title        = {XCurOS 2.2 Max: Secure Multimodal Intelligence Model},
    author       = {XCurOS Team},
    year         = {2026},
    howpublished = {Model card, \texttt{XCurOS/XCurOS-2.2-A4B-Max}},
    note         = {35B total parameters, ~4B active per token}
}