Instructions to use Rewnozom/Rewnozom with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use Rewnozom/Rewnozom with Transformers:

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

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

# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("Rewnozom/Rewnozom")
model = AutoModelForCausalLM.from_pretrained("Rewnozom/Rewnozom", device_map="auto")
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 Rewnozom/Rewnozom with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/Rewnozom/Rewnozom

SGLang

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

Docker Model Runner
How to use Rewnozom/Rewnozom with Docker Model Runner:
```
docker model run hf.co/Rewnozom/Rewnozom
```
Browse Quantizations to use this model in llama.cpp, Ollama, LM Studio, or any compatible app.

Rewnozom

Rewnozom is a reasoning- and orchestration-oriented model based on Qwen/Qwen2.5-7B-Instruct-1M.

The model keeps Qwen2 tokenizer and architecture compatibility while using a custom assistant profile focused on correctness, explicit constraints, stable software engineering behavior, and concise high-signal answers.

Original model repository: Rewnozom/Rewnozom
GGUF conversion repository: Rewnozom/Rewnozom-GGUF
Base model: Qwen/Qwen2.5-7B-Instruct-1M
Architecture: Qwen2ForCausalLM
Model type: qwen2
Context length config: 1,010,000 tokens
Primary format: safetensors
GGUF format: see README-GGUF.md
License: Apache 2.0, following the base model license

Intended Use

This model is intended for assistant-style text generation where structure and control matter:

logical reasoning over explicit constraints
software engineering assistance and code review
implementation planning and task decomposition
agent/control-plane decision support
retrieval, memory, permission, validation, and recovery workflows
long-context technical analysis

It is designed for standard Hugging Face transformers chat-template usage.

Training Signal

One training/evaluation dataset family in this workspace targets formal reasoning and kernel-like orchestration. The generators build hidden formal worlds first, solve them with deterministic oracles, and only then render natural-language prompts.

The dataset progression is:

Area	Capability
Phase 1A	Boolean CSP / unique global logic assignment
Phase 1B	Conditional task DAG activation and blocked/runnable state
Phase 1C	Pure ordering, topological planning, and plan repair
Phase 1D	Multi-hop Horn inference with verified minimum proof depth
Phase 2A	User request to structured task/requirement contract
Phase 2B	Context relevance: active, deferred, persistent, or dropped
Phase 2C	Deterministic task/fact/issue state transitions
Phase 2D	Memory lifecycle: save, load, archive, invalidate, compact, forget
Phase 2E	Abstract retrieval/navigation policy independent of a concrete tool
Phase 2F	Composite request/context/memory/retrieval/state mini-kernel
Phase 3A	Deterministic executor routing and smallest sufficient executor
Phase 3B	Exact tool-call construction and deterministic tool effects
Phase 3C	Permission classification and authorization policy
Phase 3D	Multi-agent orchestration, waiting, retry, replacement, merge
Phase 3E	Formal result validation with evidence/provenance checks
Phase 3F	Retry, correction, strategy change, replacement, escalation, abort
Phase 3G	Composite execution/control-plane kernel

Important dataset properties:

deterministic formal ground truth
primary and independent reference oracle agreement
structural duplicate rejection
exact state transitions and no-op handling for rejected actions
hard constraints separated from soft ranking
no synthetic prose chain-of-thought
stdlib-only generator design
Windows-safe multiprocessing for CPU-bound generation

The dataset is meant to reinforce behavior where the model predicts structure, routing, validation, and recovery decisions while deterministic controller code remains the source of truth for permissions, counters, hard budgets, state transitions, and actual execution.

Usage

from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "Rewnozom/Rewnozom"

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

messages = [
    {
        "role": "user",
        "content": "Review this function for correctness and edge cases.",
    },
]

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=512,
    temperature=0.63,
    top_p=0.8,
    top_k=15,
    min_p=0.03,
    repetition_penalty=1.05,
)

print(
    tokenizer.decode(
        outputs[0][inputs["input_ids"].shape[-1]:],
        skip_special_tokens=True,
    )
)

Default Generation Config

The included generation_config.json sets:

do_sample: true
temperature: 0.63
top_p: 0.8
top_k: 15
min_p: 0.03
repetition_penalty: 1.05

For stricter code, reasoning, or evaluation workflows, reduce temperature or disable sampling. For broader writing or brainstorming, increase top_p carefully and validate outputs against the task contract.

System Prompt

The default system prompt is stored in the tokenizer chat template that includes a default system prompt when the caller does not provide one. It emphasizes:

software engineering judgment
correctness before speed
stability, maintainability, performance, and clarity
explicit handling of constraints, risks, and edge cases
avoiding invented facts, APIs, dependencies, requirements, or completed work
concise answers without synthetic chain-of-thought

If an application passes its own system message, that message takes precedence.

Dataset And Conversion Logic-RL algorithm with carefully designed reward functions

The converter streams heterogeneous JSONL datasets into a fixed 16-field Arrow/Parquet schema for Logic-RL style training. It supports generated kernel datasets and external Knights-and-Knaves JSONL inputs, with lazy pyarrow import so normalization can be self-tested before Parquet dependencies are installed.