gnani-evon-v3.3

Model Overview

Model Developer: Gnani.ai

gnani-evon-v3.3

Supported languages: English, Hindi, Bengali, Telugu, Tamil, Marathi, Gujarati, Kannada, Malayalam, Odia, and Punjabi.

Release date: August 2026

gnani-evon-v3.3 is a hybrid Mamba architecture 30B MOE A3B model trained end-to-end for best-in-class Indic capability — continued pretraining, supervised fine-tuning, and reinforcement learning — delivering deep comprehension, extractive QA, and reasoning across Hindi, Bengali, Telugu, Tamil, Marathi, Gujarati, Kannada, Malayalam, Odia, Punjabi, and English. Developed by Gnani.ai, each stage was oriented toward native-script Indic language understanding and instruction following. It supports 128K context length.

The objective for this release was best-in-class Indic capability. gnani-evon-v3.3 concentrates on Indic-language comprehension, extraction, and reasoning depth, giving us a strong foundation to build on in upcoming releases.

Model Architecture

• Architecture Type: Mamba2-Transformer Hybrid Mixture of Experts (MoE)
• Network Architecture: Nemotron Hybrid MoE (nemotron_h)
• Parameters: 30B total / ~3.5B active per token
• Maximum context length: 131,072 tokens (128K)
• Precision: BF16

Key takeaways

• MILU: gnani-evon-v3.3 leads Sarvam-30B on all 11 of 11 languages at matched scale, and Sarvam-105B (≈3.5× larger) on 10 of 11
• We beat gpt-5.6-luna, a hosted frontier model, on MILU Physics (91.32 vs 88.14) — the benchmark's largest subject at 4,435 items.
• Statistical parity with gpt-5.4-nano on Indic comprehension — 79.46 against 79.69 on the nine-language macro, a 0.23-point difference, and ahead on four of those nine languages plus English.
• Indic extractive QA is our strongest competitive position: we lead every open-weight comparator on XQuAD-in (64.59 F1, +9.50) and XorQA-in (41.83 F1, +7.23).

MILU — exact scores by language

gnani-evon-v3.3 tops this MILU breakdown — ahead of Sarvam-30B on every language and ahead of Sarvam-105B on 10 of 11.

Intended Use

gnani-evon-v3.3 is a general-purpose instruction-following, reasoning, and agentic model intended for:

• English and Indic language chat and assistant applications
• Multilingual RAG systems with long context (up to 128K)
• AI agent systems with tool calling and multi-turn reasoning
• Code and mathematical reasoning
• Instruction following in English and Indic languages

Not recommended for: high-stakes decisions, legal/medical/financial advice, or deployment without safety evaluation on your target languages and domains.

Deployment geography: Global

Input / Output

• Input: Text — chat messages (OpenAI-compatible roles: system, user, assistant, tool)
• Output: Text — string, optionally with a reasoning trace
• Maximum input / output size: 131,072 tokens
• Supported languages: English, Hindi, Bengali, Telugu, Tamil, Marathi, Gujarati, Kannada, Malayalam, Odia, Punjabi

Software Integration

• Runtime Engine(s): Transformers ≥ 5.3.0, vLLM ≥ 0.12.0, SGLang
• Supported Hardware: NVIDIA H100 80GB, NVIDIA H200, NVIDIA A100
• Operating System(s): Linux

Quick Start Guide

Use it with Transformers

Requires trust_remote_code=True

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

model_id = "gnani/gnani-evon-v3.3"

tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    trust_remote_code=True,
    device_map="auto",
)

messages = [
    {"role": "user", "content": "Explain photosynthesis in Hindi."},
]

tokenized_chat = tokenizer.apply_chat_template(
    messages,
    tokenize=True,
    add_generation_prompt=True,
    return_tensors="pt",
).to(model.device)

outputs = model.generate(
    tokenized_chat,
    max_new_tokens=1024,
    temperature=0.6,
    top_p=0.95,
    eos_token_id=tokenizer.eos_token_id,
)
print(tokenizer.decode(outputs[0]))

Use temperature=0.6 and top_p=0.95 for best results across reasoning, tool calling, and general instruction following.

To disable reasoning traces, pass enable_thinking=False to apply_chat_template.

Use it with vLLM

pip install -U "vllm>=0.12.0"

vllm serve gnani/gnani-evon-v3.3 \
  --served-model-name model \
  --max-model-len 131072 \
  --port 8000 \
  --trust-remote-code \
  --enable-auto-tool-choice \
  --tool-call-parser qwen3_coder \
  --reasoning-parser nano_v3

Example client request:

curl http://localhost:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "model",
        "messages": [{"role": "user", "content": "Write a haiku about monsoon rains in Tamil."}],
        "max_tokens": 4096
    }'

To disable reasoning with vLLM, add "chat_template_kwargs": {"enable_thinking": false} to the request body.

SGLang

pip install "sglang[all]" ninja

Start the server:

python -m sglang.launch_server \
    --model-path gnani/gnani-evon-v3.3 \
    --served-model-name gnani-evon-v3.3 \
    --dtype bfloat16 \
    --context-length 131072 \
    --mem-fraction-static 0.90 \
    --moe-runner-backend triton \
    --host 0.0.0.0 --port 30000

--moe-runner-backend triton selects the Triton mixture of experts kernels instead of the CUTLASS ones. The CUTLASS path is compiled on first use and that build needs a CUDA toolchain whose compiler and headers are the same version, which is not the case in many pip-only installs. The Triton path needs no such build and starts cleanly. Drop the flag if your CUDA toolchain is consistent and you want the CUTLASS kernels.

Add --tp 2 or higher for longer context or higher concurrency. Lower --mem-fraction-static if the server runs out of memory while capturing graphs.

Send a request to the OpenAI-compatible endpoint:

curl http://localhost:30000/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "gnani-evon-v3.3",
    "messages": [
      {"role": "user", "content": "ಸೌರಶಕ್ತಿಯ ಮೂರು ಉಪಯೋಗಗಳನ್ನು ತಿಳಿಸಿ."}
    ],
    "max_tokens": 2048,
    "temperature": 0.6,
    "top_p": 0.95,
    "chat_template_kwargs": {"enable_thinking": true}
  }'

Recommended Inference Settings

Two request configurations cover most use cases. Choose based on whether the task needs multi-step reasoning.

Deterministic single answer — factual QA, classification, short structured replies (e.g. multiple-choice, one-line answers). Reasoning off, near-greedy:

{
  "model": "model",
  "messages": [
    {"role": "system", "content": "Respond in the same language and script as the question."},
    {"role": "user", "content": "..."}
  ],
  "temperature": 0.6,
  "top_p": 0.95,
  "repetition_penalty": 1.1,
  "max_tokens": 2048,
  "chat_template_kwargs": { "enable_thinking": false },
  "stream": false
}

Reasoning — math, physics, multi-step problems where accuracy matters more than latency. Reasoning on, with temperature=0.6 and top_p=0.95:

{
  "model": "model",
  "messages": [
    {"role": "system", "content": "Respond in the same language and script as the question."},
    {"role": "user", "content": "..."}
  ],
  "temperature": 0.6,
  "top_p": 0.95,
  "repetition_penalty": 1.0,
  "max_tokens": 16384,
  "chat_template_kwargs": { "enable_thinking": true },
  "stream": false
}

Notes:

• Non-reasoning mode is faster but slightly less accurate on prompts that require multi-step reasoning; enable thinking for those.
• Avoid combining a hard no_repeat_ngram_size with repetition_penalty on very short answers — legitimate repetition (units, option letters) can be blocked, forcing awkward phrasing.
• For strictly native-script output, keep a system instruction that names the target language and script, and verify the response script downstream.

Training Overview

gnani-evon-v3.3 was built specifically for Indic capabilities — comprehension, extraction, reasoning, and instruction following across English and Indic languages. Every training stage was oriented toward that goal:

• Pretraining on a blended English + Indic corpus to strengthen multilingual foundations and long-context Indic representation.
• Supervised fine-tuning (SFT) on instruction and capability-focused datasets covering QA, summarization, safety, and multi-turn dialogue in native scripts.
• Reinforcement learning (GRPO) to sharpen reasoning quality, refusal behavior, and task completion on Indic-heavy prompts.

Training ran on H200 GPU clusters using NVIDIA's NeMo software stack: NeMo Curator, Megatron Bridge, and NeMo RL.

Data collection & labeling: Hybrid — automated, human, and synthetic.

Evaluation

Indic Benchmarks

Indic Frontier Models Comparison

Open Source Models Comparison

Safety and Security Evaluation

Evaluated on IndicSafe — 5,965 rows across 12 Indic languages.

Overall accuracy: 86.50%

Accuracy by Harm Category (%)

Key observations:

• Strongest categories: Harmless Control (97.93%) and Tricky Ambiguous (97.77%).
• Misinformation / Conspiracy (83.50%) is a relative strength among harm categories.
• Gender & Caste Discrimination (70.26%) is the hardest category.

MILU by Language — vs Hosted Models (identical items & prompts)

Limitations & Ongoing Work

• Tool use and agentic capabilities are an active area of development. We are working to improve multi-step tool use to match frontier-model capabilities at a similar model size.

Ethical Considerations

• Evaluate the model on their target languages, domains, and use cases before deployment.
• Implement appropriate safety guardrails for production use.
• Be aware of potential biases in web-scraped and synthetic training data.
• Not use the model for high-stakes decisions without human oversight.
• Ensure any voice or conversational agent built on this model discloses that it is AI.

Looking ahead: this model is the Indic-capability foundation for our next plan, where we focus on improving the model further — layering in strong agentic capabilities such as multi-step tool use, planning, and orchestration.

Citation

@misc{gnani_evon_v33_2026,
  title  = {{gnani-evon-v3.3}: Hybrid {Mamba} {MoE} 30B-A3B Model Trained End-to-End for Best-in-Class Indic Capability},
  author = {{Gnani.ai}},
  year   = {2026},
  url    = {https://huggingface.co/gnani/gnani-evon-v3.3}
}