Instructions to use Ajeet-001/Nischay with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use Ajeet-001/Nischay with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("image-text-to-text", model="Ajeet-001/Nischay")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
pipe(text=messages)

# pip install -U transformers accelerate
# Load model directly
from transformers import AutoProcessor, AutoModelForMultimodalLM

processor = AutoProcessor.from_pretrained("Ajeet-001/Nischay")
model = AutoModelForMultimodalLM.from_pretrained("Ajeet-001/Nischay", device_map="auto")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
inputs = processor.apply_chat_template(
	messages,
	add_generation_prompt=True,
	tokenize=True,
	return_dict=True,
	return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=256)
print(processor.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use Ajeet-001/Nischay with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "Ajeet-001/Nischay"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Ajeet-001/Nischay",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Use Docker

docker model run hf.co/Ajeet-001/Nischay

SGLang

How to use Ajeet-001/Nischay with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "Ajeet-001/Nischay" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Ajeet-001/Nischay",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "Ajeet-001/Nischay" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Ajeet-001/Nischay",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Docker Model Runner
How to use Ajeet-001/Nischay with Docker Model Runner:
```
docker model run hf.co/Ajeet-001/Nischay
```

Nischay (8B / E4B Multimodal Decision Engine)

Nischay (decisive, resolute, certain) is an 8B total-parameter (7.94B total / 3.89B E4B effective active decoder compute) multimodal decision model engineered for single-pass, calibrated structured decisions over text and images.

Given a state (structured JSON, plain text, or 1–4 images) and a set of typed questions (noul binary/abstention, choice multi-option selection up to 256 options, or score ordinal ratings), Nischay returns a calibrated probability distribution over every option in one shared-prefix prefill and one batched suffix forward pass—never sampling tokens autoregressively.

Key Capabilities & Highlights

Unified Text + Vision Decision Engine: Handles multi-question text states (~60 ms for 3 questions on one GPU) and multimodal visual reasoning (KIE, InfographicVQA, CV-Bench, Winoground, CharXiv, RealWorldQA) within the same architecture.
8B Total / 4B Effective Decoder Architecture (7.94B Parameters): Combines a 3.89B core transformer decoder with 2.90B Per-Layer Embeddings (PLE), a 0.67B token embedding table, and native multimodal vision (0.17B) + audio (0.31B) encoders (14.79 GB in bfloat16).
Block-Bidirectional Readout (noncausal + slot_lm): Full-attention layers use a block-bidirectional mask where the shared state prefix is causal and each question/option suffix attends bidirectionally within its own block, paired with a 256-slot LM head readout (A–Z and two-letter slots).
Calibrated Probability Distributions: Trained with a joint Cross-Entropy + Brier calibration objective (λ = 1.0) and 1:1 soft-teacher + hard-target probability supervision, achieving 3.62% ECE on text and 8.90% ECE on multimodal vision decisions.
Strict Benchmark Decontamination: Zero overlap with the Jev Decision Index (0.3 / 0.4 text and vision-0.3 suites), enforced via exact dataset exclusion and SHA-256 normalized text deduplication.

Model Details

Property	Specification
Model Name	Nischay (`Ajeet-001/Nischay`)
Total Parameters	`7,941,101,802` (`7.94B` / ~8B total)
Parameter Breakdown	`3.89B` Core Transformer Decoder (`E4B` effective compute) + `2.90B` Per-Layer Embeddings (PLE) + `0.67B` Token Embeddings + `0.17B` Vision Tower + `0.31B` Audio Tower
Inputs	Text (structured JSON / documents / dialogues) and Images (1–4 images per request, up to 1.6 MP per image)
Attention Mechanism	`block_bidirectional` (`noncausal`) on full-attention layers; shared prefix cached across all questions
Readout Mechanism	`slot_lm` (256 single-token option slots, upcast `float32` readout head over `bfloat16` backbone)
Calibration	`calibration.json` included (`T = 0.70` text / `T = 1.0` multimodal)
Precision	`bfloat16` weights (`model.safetensors`, `14.79 GB`), `float32` output head

How to Use

1. One-Command Environment Setup (`setup.sh`)

setup.sh installs the pinned serving runtime (OneJev @ 81ce62f1 + serve.patch) and the official decision-index evaluation kit:

hf download Ajeet-001/Nischay --local-dir Nischay && bash Nischay/setup.sh

2. Python Quickstart (`DecisionEngine`)

from qev.engine import DecisionEngine
from qev.schema import SystemOneRequest

engine = DecisionEngine("Ajeet-001/Nischay", device="cuda:0")

questions = {
    "refund": {"type": "noul", "instructions": "Is the customer asking for a refund?"},
    "team": {
        "type": "choice",
        "instructions": "Which team should handle this?",
        "criteria": {
            "billing": "Charges, refunds, invoices",
            "technical": "App or site faults",
            "fraud": "Suspected unauthorised use",
        },
    },
    "urgency": {
        "type": "score",
        "instructions": "How urgent is this?",
        "criteria": ["Can wait", "Today", "Blocking the customer now"],
    },
}

resp, meta = engine.decide(SystemOneRequest(
    state="I was charged twice this month, please refund one of them.",
    questions=questions,
))
print(resp.answers)

Question `type`	`criteria` Format	Returned Fields
`noul` (yes / no / abstention)	optional	`noul`: $P(\text{yes})$
`choice` (named options)	`{key: description}`	`choice`, `probabilities`
`score` (ordered ordinal levels)	`[lowest, ..., highest]`	`score`, `probabilities`

3. Running on the Jev Decision Index (`engine.py`)

This repository ships engine.py (DecisionModel), which supports both the Text and Vision suites of the Jev Decision Index out of the box:

# Text Decision Index Suite (0.3 / 0.4)
PYTHONPATH=Nischay:OneJev python -m decision_index pipeline \
    --engine engine:DecisionModel \
    --option model=Ajeet-001/Nischay \
    --out runs/nischay-text

# Vision Decision Index Suite (0.3)
PYTHONPATH=Nischay:OneJev python -m decision_index vision pipeline \
    --dir work/vision \
    --engine engine:DecisionModel \
    --option model=Ajeet-001/Nischay \
    --out runs/nischay-vision

Requests longer than the model's capacity limit raise Unsupported (never truncated, no option filtering, no per-benchmark prompt tuning).

Benchmark Performance (`Jev Decision Index 0.3 / 0.4`)

Complete evaluation artifacts (results.jsonl.gz and scores.json) are published in Ajeet-001/Nischay-decision-index-results.

1. Overall Comparison with Sub-15B & Compact Decision Models

Model	Parameters	Modalities	Public Vision Index 0.3	Public Text Index 0.3 / 0.4
`elephant-1`	9B	Text + Vision	—	62.65
`JPT-9B`	9B	Text-only	—	46.96
Nischay (`Ajeet-001/Nischay`)	8B (`7.94B` total / `3.89B` E4B decoder)	Text + Vision	44.96 (`12,210 / 12,210` rows)	37.94 (`53.24%` raw)
`JPT-0.8B`	0.8B	Text-only	—	19.37
`Lavoir`	—	Text-only	—	8.85
`Verdict`	—	Text-only	—	1.86

2. Text Decision Index 0.3 — Area-Level Comparison (8B–9B Peer Class)

Area	Benchmarks (`n`)	Nischay (8B / E4B)	`JPT-9B` (9B)	`JPT-0.8B` (0.8B)
Tools & Automation	5	60.40 (`63.68%` raw)	67.02	36.23
Language Understanding	9	41.76 (`60.37%` raw)	57.68	25.17
Retrieval & Classification	6	41.73 (`55.56%` raw)	44.59	16.40
Arts & Human Taste	6	29.19 (`51.45%` raw)	28.78	8.44
Knowledge & Reasoning	11	18.70 (`37.61%` raw)	30.92	8.16
Overall Public Text Index	37	37.94 (`53.24%` raw)	46.96	19.37

3. Vision Decision Index 0.3 — Summary (`12,210 / 12,210` Rows, `complete: true`)

Nischay is the first sub-10B multimodal decision engine evaluated on the complete 11-benchmark Official Vision Decision Index 0.3 (12,210 / 12,210 rows answered, 0 errors), achieving an overall Public Vision Index of 44.96, led by KIE (81.70 skill / 88.88% accuracy), InfographicVQA (74.32 skill / 80.74% accuracy), CV-Bench (60.50 skill / 76.05% accuracy), Winoground (60.00 skill / 80.00% accuracy), and CharXiv (49.12 skill / 61.84% accuracy), while outperforming the 27B Solomon v1.1 vision decision model on R-Bench-M (21.31 vs 18.24) and MMMU-Pro Vision (10.96 vs -2.56).

4. Held-Out Calibration & Decision Type Breakdown

Evaluation Split	Overall Accuracy (↑)	`noul` (Binary / Abstention) (↑)	`choice` (Multi-Option) (↑)	`score` (Ordinal) (↑)	NLL (↓)	ECE (↓)
Text Held-Out (`n=200`)	85.00%	93.20%	78.67%	81.82%	0.4728	3.62%
Vision Held-Out (`n=150`)	56.67%	69.57%	53.16%	44.00%	1.1055	8.90%

Repository Contents

Every file required to load, serve, and benchmark Nischay is included in this repository:

model.safetensors, config.json, generation_config.json: Full merged bfloat16 model weights (7.94B total parameters, 14.79 GB) and architecture configuration (with modeling_overrides for block_bidirectional full attention).
tokenizer.json, tokenizer_config.json, processor_config.json, chat_template.jinja: Multimodal processor and tokenizer configuration.
readout.json, calibration.json: Readout specification (noncausal + slot_lm, 256 slots) and temperature calibration.
engine.py: Ready-to-run DecisionModel(Engine) adapter for the Jev Decision Index (decision_index text and vision pipelines).
serve.patch, setup.sh, constraints.txt: Reproducible one-command installation of the OneJev runtime and decision-index kit.

Downloads last month: -

Safetensors

Model size

8B params

Tensor type

BF16