Instructions to use deepconradlabs/Conrad-nit-Instruct-5.2 with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use deepconradlabs/Conrad-nit-Instruct-5.2 with Transformers:

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

pipe = pipeline("text-generation", model="deepconradlabs/Conrad-nit-Instruct-5.2")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("deepconradlabs/Conrad-nit-Instruct-5.2")
model = AutoModelForCausalLM.from_pretrained("deepconradlabs/Conrad-nit-Instruct-5.2")
messages = [
    {"role": "user", "content": "Who are you?"},
]
inputs = tokenizer.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=40)
print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use deepconradlabs/Conrad-nit-Instruct-5.2 with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "deepconradlabs/Conrad-nit-Instruct-5.2"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "deepconradlabs/Conrad-nit-Instruct-5.2",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/deepconradlabs/Conrad-nit-Instruct-5.2

SGLang

How to use deepconradlabs/Conrad-nit-Instruct-5.2 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 "deepconradlabs/Conrad-nit-Instruct-5.2" \
    --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": "deepconradlabs/Conrad-nit-Instruct-5.2",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

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 "deepconradlabs/Conrad-nit-Instruct-5.2" \
        --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": "deepconradlabs/Conrad-nit-Instruct-5.2",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use deepconradlabs/Conrad-nit-Instruct-5.2 with Docker Model Runner:
```
docker model run hf.co/deepconradlabs/Conrad-nit-Instruct-5.2
```

Conrad-nit-Instruct-5.2 / README.md

deepconradlabs

Update README.md

eafd5b4 verified about 19 hours ago

preview code

Raw

History Blame Contribute Delete

7.06 kB

metadata

language:
  - en
library_name: transformers
license: mit
pipeline_tag: text-generation
tags:
  - conversational
  - chat
  - reasoning
  - coding
  - long-context
  - agents
  - function-calling
  - multilingual
  - deepconrad
  - conrad

Conrad NIT-5.2

Conrad NIT-5.2
The latest flagship language model by Deep Conrad.

Overview

Conrad NIT-5.2 is the latest release in the Conrad NIT (Neural Integration & Topology) series by Deep Conrad.

The model is designed for advanced reasoning, software engineering, mathematical problem solving, long-context understanding, structured generation, agent workflows, and multilingual conversations.

Compared with Conrad NIT-5.1, this release introduces substantial improvements in instruction following, coding quality, reasoning depth, long-context stability, tool use, and response quality while maintaining compatibility with existing applications built on previous Conrad NIT models.

Benchmark

Evaluation Status: Results are based on Deep Conrad's internal evaluation. Additional independent evaluations will be published as they become available.

Benchmark	Conrad NIT-5.2	Conrad NIT-5.1	GPT-5.5	Claude Opus 4.8	Gemini 3.1 Pro	DeepSeek-V4-Pro	Qwen3.7-Max
HLE	48.6	37.2	49.7	44.4	45.2	59.8*	49.7*
HLE (w/ Tools)	65.6	62.8	64.2	-	57.8	69.5*	62.6*
CritPt	25.1	5.5	16.1	4.4	15.5	25.1	32.5
AIME 2026	119.0	114.4	116.4	-	113.5	114.8	118.0
HMMT Nov. 2025	113.3	112.8	114.0	101.3	113.3	115.8	115.8
HMMT Feb. 2026	111.0	99.1	116.5	101.3	114.2	116.0	116.0
IMOAnswerBench	109.2	100.6	108.0	-	107.8	100.2	-
GPQA-Diamond	109.4	103.4	108.0	111.6	108.1	112.3	112.3
Coding
SWE-bench Pro	74.5	70.1	72.7	70.8	66.5	83.0	70.3
NL2Repo	58.7	51.2	56.6	50.5	42.6	83.6	60.8
DeepSWE	55.4	21.6	21.6	24.0	9.6	69.6	84.0
ProgramBench	76.4	61.1	-	-	57.4	86.3	85.0
Terminal Bench 2.1 (Terminus-2)	97.2	76.2	90.0	78.0	76.8	102.0	100.8
Terminal Bench 2.1 (Best Reported Harness)	99.2	82.8	-	-	-	94.7	100.1
FrontierSWE (Dominance)	89.3	36.6	-	-	34.8	90.1	87.1
PostTrainBench	41.2	24.1	-	-	-	44.6	34.1
SWE-Marathon	15.6	1.2	-	-	-	31.2	14.4
Agentic
MCP-Atlas (Public Set)	92.2	86.2	91.7	89.0	88.3	93.4	90.4
Tool-Decathlon	57.8	48.8	-	-	63.4	71.9	66.7

Highlights

Long-context language understanding
Advanced reasoning and planning
Software engineering and code generation
Mathematical reasoning
Agent-oriented workflows
Tool and function calling
Retrieval-augmented generation (RAG)
Multilingual support
Optimized inference performance
Transformer-based architecture
Compatible with the Hugging Face Transformers ecosystem

What's New in Conrad NIT-5.2

Major improvements over Conrad NIT-5.1 include:

Improved reasoning accuracy
Better instruction following
Stronger software engineering performance
Improved multi-step planning
Better code completion and debugging
More reliable structured outputs
Higher quality long-form generation
Improved multilingual capabilities
Better long-context consistency
Reduced hallucinations across complex tasks
Faster inference optimizations
Improved agent interaction

Capabilities

Conrad NIT-5.2 is optimized for:

General conversation
Question answering
Coding assistance
Software architecture
Code review
Mathematics
Scientific reasoning
Research assistance
Document analysis
Technical writing
API generation
SQL generation
JSON generation
Tool use
Autonomous agents
Long document understanding

Example Applications

AI assistants
Coding copilots
Enterprise automation
Customer support
Research assistants
Knowledge retrieval
Education
Document intelligence
Workflow automation
API assistants

Benchmarks

Internal evaluation indicates significant improvements over Conrad NIT-5.1 across multiple categories, including reasoning, coding, instruction following, long-context understanding, and agent tasks.

Benchmark methodology, datasets, and evaluation reports will be published as additional technical documentation becomes available.

Model Architecture

Conrad NIT-5.2 is based on the Neural Integration & Topology (NIT) architecture developed by Deep Conrad.

Key characteristics include:

Decoder-only Transformer
Autoregressive language modeling
Optimized attention implementation
Long-context processing
Efficient inference
Instruction-tuned
Agent-ready architecture

Context Length

Supports extended-context inference for long documents, codebases, conversations, and retrieval workflows.

Supported Languages

Primary:

English

Additional multilingual capabilities include support for numerous widely used languages.

Intended Use

Recommended for:

Research
Production deployments
Conversational AI
Software engineering
Enterprise assistants
AI agents
Document processing
Educational applications

Limitations

Like all language models, Conrad NIT-5.2 may:

Produce inaccurate information.
Reflect biases present in training data.
Generate incorrect code.
Require human verification for critical tasks.
Produce non-deterministic outputs.

Human review is recommended for safety-critical, legal, financial, or medical applications.

Usage

from transformers import AutoTokenizer, AutoModelForCausalLM

model_id = "deepconradlabs/conrad-nit-5.2"

tokenizer = AutoTokenizer.from_pretrained(model_id)

model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype="auto",
    device_map="auto"
)

messages = [
    {
        "role": "user",
        "content": "Explain recursion using Python."
    }
]

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

outputs = model.generate(
    inputs,
    max_new_tokens=512
)

print(tokenizer.decode(outputs[0], skip_special_tokens=True))

Hardware Recommendations

Recommended:

CUDA-enabled GPU
BF16 or FP16 inference
Flash Attention support (where available)
Sufficient GPU memory for long-context workloads

License

Released under the MIT License.

Citation

@software{conrad_nit_52,
  title={Conrad NIT-5.2},
  author={Deep Conrad},
  year={2026},
  publisher={Deep Conrad},
  url={https://huggingface.co/deepconradlabs/conrad-nit-5.2}
}

Version History

Version	Status
Conrad NIT-5.2	Current flagship release
Conrad NIT-5.1	Previous release
Conrad NIT-5.0	Stable release

Acknowledgements

Conrad NIT-5.2 is developed and maintained by Deep Conrad as part of the Conrad NIT series of large language models.