Instructions to use iBossonline/RegesCore-1.0-35 with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use iBossonline/RegesCore-1.0-35 with Transformers:

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

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

# Load model directly
from transformers import AutoModel
model = AutoModel.from_pretrained("iBossonline/RegesCore-1.0-35", device_map="auto")

Notebooks
Google Colab
Kaggle
Local Apps Settings

llama.cpp

How to use iBossonline/RegesCore-1.0-35 with llama.cpp:

Install (macOS, Linux)

curl -LsSf https://llama.app/install.sh | sh
# Start a local OpenAI-compatible server with a web UI:
llama serve -hf iBossonline/RegesCore-1.0-35:UD-Q4_K_M
# Run inference directly in the terminal:
llama cli -hf iBossonline/RegesCore-1.0-35:UD-Q4_K_M

Install from WinGet (Windows)

winget install llama.cpp
# Start a local OpenAI-compatible server with a web UI:
llama serve -hf iBossonline/RegesCore-1.0-35:UD-Q4_K_M
# Run inference directly in the terminal:
llama cli -hf iBossonline/RegesCore-1.0-35:UD-Q4_K_M

Use pre-built binary

# Download pre-built binary from:
# https://github.com/ggerganov/llama.cpp/releases
# Start a local OpenAI-compatible server with a web UI:
./llama-server -hf iBossonline/RegesCore-1.0-35:UD-Q4_K_M
# Run inference directly in the terminal:
./llama-cli -hf iBossonline/RegesCore-1.0-35:UD-Q4_K_M

Build from source code

git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp
cmake -B build
cmake --build build -j --target llama-server llama-cli
# Start a local OpenAI-compatible server with a web UI:
./build/bin/llama-server -hf iBossonline/RegesCore-1.0-35:UD-Q4_K_M
# Run inference directly in the terminal:
./build/bin/llama-cli -hf iBossonline/RegesCore-1.0-35:UD-Q4_K_M

Use Docker

docker model run hf.co/iBossonline/RegesCore-1.0-35:UD-Q4_K_M

LM Studio
Jan

vLLM

How to use iBossonline/RegesCore-1.0-35 with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/iBossonline/RegesCore-1.0-35:UD-Q4_K_M

SGLang

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

Ollama
How to use iBossonline/RegesCore-1.0-35 with Ollama:
```
ollama run hf.co/iBossonline/RegesCore-1.0-35:UD-Q4_K_M
```

Unsloth Studio

How to use iBossonline/RegesCore-1.0-35 with Unsloth Studio:

Install Unsloth Studio (macOS, Linux, WSL)

curl -fsSL https://unsloth.ai/install.sh | sh
# Run unsloth studio
unsloth studio -H 0.0.0.0 -p 8888
# Then open http://localhost:8888 in your browser
# Search for iBossonline/RegesCore-1.0-35 to start chatting

Install Unsloth Studio (Windows)

irm https://unsloth.ai/install.ps1 | iex
# Run unsloth studio
unsloth studio -H 0.0.0.0 -p 8888
# Then open http://localhost:8888 in your browser
# Search for iBossonline/RegesCore-1.0-35 to start chatting

Using HuggingFace Spaces for Unsloth

# No setup required
# Open https://huggingface.co/spaces/unsloth/studio in your browser
# Search for iBossonline/RegesCore-1.0-35 to start chatting

How to use iBossonline/RegesCore-1.0-35 with Pi:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf iBossonline/RegesCore-1.0-35:UD-Q4_K_M

Configure the model in Pi

# Install Pi:
npm install -g @mariozechner/pi-coding-agent
# Add to ~/.pi/agent/models.json:
{
  "providers": {
    "llama-cpp": {
      "baseUrl": "http://localhost:8080/v1",
      "api": "openai-completions",
      "apiKey": "none",
      "models": [
        {
          "id": "iBossonline/RegesCore-1.0-35:UD-Q4_K_M"
        }
      ]
    }
  }
}

Run Pi

# Start Pi in your project directory:
pi

Hermes Agent new

How to use iBossonline/RegesCore-1.0-35 with Hermes Agent:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf iBossonline/RegesCore-1.0-35:UD-Q4_K_M

Configure Hermes

# Install Hermes:
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash
hermes setup
# Point Hermes at the local server:
hermes config set model.provider custom
hermes config set model.base_url http://127.0.0.1:8080/v1
hermes config set model.default iBossonline/RegesCore-1.0-35:UD-Q4_K_M

Run Hermes

hermes

Atomic Chat new

OpenClaw new

How to use iBossonline/RegesCore-1.0-35 with OpenClaw:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf iBossonline/RegesCore-1.0-35:UD-Q4_K_M

Configure OpenClaw

# Install OpenClaw:
npm install -g openclaw@latest
# Register the local server and set it as the default model:
openclaw onboard --non-interactive --mode local \
  --auth-choice custom-api-key \
  --custom-base-url http://127.0.0.1:8080/v1 \
  --custom-model-id "iBossonline/RegesCore-1.0-35:UD-Q4_K_M" \
  --custom-provider-id llama-cpp \
  --custom-compatibility openai \
  --custom-text-input \
  --accept-risk \
  --skip-health

Run OpenClaw

openclaw agent --local --agent main --message "Hello from Hugging Face"

Docker Model Runner
How to use iBossonline/RegesCore-1.0-35 with Docker Model Runner:
```
docker model run hf.co/iBossonline/RegesCore-1.0-35:UD-Q4_K_M
```

Lemonade

How to use iBossonline/RegesCore-1.0-35 with Lemonade:

Pull the model

# Download Lemonade from https://lemonade-server.ai/
lemonade pull iBossonline/RegesCore-1.0-35:UD-Q4_K_M

Run and chat with the model

lemonade run user.RegesCore-1.0-35-UD-Q4_K_M

List all available models

lemonade list

██████████████████████████████████████████████████████████████████████████████████████████

██████╗ ███████╗ ██████╗ ███████╗███████╗ ██████╗ ██████╗ ██████╗ ███████╗     █████╗ ██╗
██╔══██╗██╔════╝██╔════╝ ██╔════╝██╔════╝██╔════╝██╔═══██╗██╔══██╗██╔════╝    ██╔══██╗██║
██████╔╝█████╗  ██║  ███╗█████╗  ███████╗██║     ██║   ██║██████╔╝█████╗      ███████║██║
██╔══██╗██╔══╝  ██║   ██║██╔══╝  ╚════██║██║     ██║   ██║██╔══██╗██╔══╝      ██╔══██║██║
██║  ██║███████╗╚██████╔╝███████╗███████║╚██████╗╚██████╔╝██║  ██║███████╗    ██║  ██║██║
╚═╝  ╚═╝╚══════╝ ╚═════╝ ╚══════╝╚══════╝ ╚═════╝ ╚═════╝ ╚═╝  ╚═╝╚══════╝    ╚═╝  ╚═╝╚═╝

███████████████████████████ T H E   A I   M A S T E R M I N D ████████████████████████████
██████████████████████████████████████████████████████████████████████████████████████████
████████████ OFFSEC · REVERSE ENGINEERING · SYSTEMS · GAME SERVERS · LOCAL AI ████████████
██████████████████████████████████████████████████████████████████████████████████████████

Interface download link: https://huggingface.co/iBossonline/RegesCore-1.0-35/blob/main/Fleet%20Nominal%20Interface%20Redesign%20(1).zip

keep in mind. this is starter template.

if you like it, share some love.

here is benchmark repo as well to test it by yourself https://github.com/iboss21/regescore-benchmark/tree/main

The services above are all powered by this MoE build of RegesCore AI — internally aka Jarvis.

The AI Mastermind for ethical hacking, elite systems engineering, and advanced game-server architecture.

Reasoning-first · Agent-native · 100% local · MIT licensed

Built by iBoss21 / Like A King Inc. — the engineering brain of the Reges.Core automation platform.

🧭 Navigation


🎯 TL;DR	⚡ At a Glance	💡 Why RegesCore
🛡️ The Armory	🚀 Use Cases	📇 Model Details
📥 Quantization Guide	📊 Benchmarks	🧠 Intelligence Architecture
📝 System Prompt	⚙️ Prompting Guide	🔌 Integration
💻 Quickstart	📦 Repo Layout	❓ FAQ
🗺️ Roadmap	🏛️ Ecosystem	📜 License

██████████████████████████████████████████████████████████████████████████████████████████ ████████████████████████████████████████ 🎯 TL;DR ████████████████████████████████████████ ██████████████████████████████████████████████████████████████████████████████████████████

RegesCore-1.0-35B is a fine-tuned AI Mastermind — an agent-first, reasoning-capable security and systems-engineering model that runs 100% offline on your own hardware. It thinks before it answers (<think> blocks), calls tools in structured XML, distinguishes FACT / INFERENCE / UNKNOWN, and carries deep operational knowledge of offensive & defensive security tooling, low-level systems programming, and FiveM/RedM game-server runtimes. MIT licensed, GGUF format, built on Ornith-1.0-35B.

██████████████████████████████████████████████████████████████████████████████████████████ █████████████████████████████████████ ⚡ AT A GLANCE █████████████████████████████████████ ██████████████████████████████████████████████████████████████████████████████████████████


Model	RegesCore-1.0-35B
Alias	The AI Mastermind · Jarvis
Architecture	Qwen3.5 MoE (derived from Ornith-1.0-35B)
Parameters	~35B total — sparse MoE (only a fraction active per token)
Format	GGUF (22 quantizations + BF16 split)
Context	Up to 128K native (base); GGUF builds default to 32K
Reasoning	`<think>…</think>` — plan privately, then answer
Tool calls	Native XML `<tool_call>` (JSON optional)
Truth model	Every claim labeled FACT / INFERENCE / UNKNOWN
License	MIT — commercial use OK, no regional restrictions
Base model	deepreinforce-ai/Ornith-1.0-35B
GGUF source	unsloth/Ornith-1.0-35B-GGUF
Privacy	100% local — no telemetry, your data never leaves the box
Portable sibling	RegesCore-1.0-9B — 5.4 GB @ Q4, runs on laptops

██████████████████████████████████████████████████████████████████████████████████████████ ████████████████████████████████████ 💡 WHY REGESCORE ████████████████████████████████████ ██████████████████████████████████████████████████████████████████████████████████████████

Pillar	What it means
⚔️ Ethical hacking, on your own iron	Penetration-testing methodology, recon & exploitation toolchains, reverse engineering, forensics — offline, private, no third parties.
🤝 A security partner, not a chatbot	Trained to distinguish FACT from INFERENCE from UNKNOWN — and to verify instead of guess before it answers.
🎮 Game-server native	FiveM / RedM runtimes (QBCore, ESX, VorpCore, VCore): LuaJIT internals, metatables, coroutines, memory, async DB saving.
🏗️ Principal-level engineering	Bare-metal ops, kernel tuning, cloud architecture, PostgreSQL / Redis / ClickHouse, event-driven systems, agentic tool use.
🧠 Reasoning by design	Opens with a `<think>` block, plans, then acts — structured XML tool calls in agent environments.
📜 MIT licensed	Fully open, consistent with its base model, no regional restrictions.

RegesCore is the engineering brain of the Reges.Core AI automation platform — a core intelligence of the Like A King Inc. ecosystem, deployed across infrastructure, game servers, security operations, and AI operations.

██████████████████████████████████████████████████████████████████████████████████████████ █████████████████████████████ 🛡️ THE ARMORY — CAPABILITIES ██████████████████████████████ ██████████████████████████████████████████████████████████████████████████████████████████

1 · Offensive Security & Reverse Engineering

Domain	Toolchain
Recon & exploitation	Nmap · Metasploit Framework · Burp Suite (Community/Pro) · SQLmap · Hashcat · John the Ripper
Reverse engineering & forensics	Ghidra · Radare2 · x64dbg · Frida (dynamic instrumentation) · Wireshark · malware / exploit analysis · memory forensics
Infrastructure testing	BloodHound (Active Directory) · Kube-hunter (Kubernetes) · Trivy (container scanning)
Defensive infrastructure	Wazuh (SIEM/XDR) · Suricata · Zeek · eBPF telemetry · WireGuard · Tailscale/Headscale · Cloudflare Tunnels
Security operations	Penetration-testing methodology · threat modeling · detection engineering · SOC/SIEM/EDR workflows

2 · Low-Level & Systems Programming · Game Servers

Domain	Coverage
Systems languages	C/C++ (manual memory, ABI, POSIX) · Rust (borrow checker, `unsafe` auditing, Tokio) · Go (goroutines, GC tuning)
Managed runtimes	C#/.NET (CLR, async state machines, EF Core) · Python (asyncio, C-extensions, GIL constraints)
Game-server runtimes	Lua 5.1/5.4 & LuaJIT for RedM & FiveM — QBCore · ESX · VorpCore · VCore. Metatables, coroutines, memory isolation, server thread management, `oxmysql` async saving, anti-cheat heuristics
Agentic workflows	Codebase navigation · multi-file refactors · build/test loops · shell automation

3 · Cloud · Backend · Bare-Metal Operations

Domain	Stack
Infrastructure	Bare-metal deployment · self-hosted PaaS (Coolify) · Docker · Kubernetes · Nginx / Caddy / Traefik · Linux kernel tuning · systemd · eBPF
Databases	PostgreSQL · Redis · ClickHouse · SQLite · vector DBs — execution plans, B-Tree/GIN/GiST/BRIN indexing, pooling, ACID, replication, sharding
Backend & messaging	Node.js/V8 · Go · Rust · .NET Core · FastAPI · event-driven architecture (RabbitMQ, Kafka) · REST / gRPC / GraphQL · IPC · WebAssembly
Frontend	React · Next.js · Tailwind CSS · WebSockets · render-pipeline optimization · bundle splitting · WASM integration

4 · Local AI & Inference Engineering

Domain	Stack
Runtimes & serving	Ollama · llama.cpp · vLLM · TensorRT-LLM · TGI
Quantization	GGUF · AWQ · EXL2 · GPU-memory profiling · model routing · cost/perf trade-offs
Orchestration & RAG	LangChain · LlamaIndex · ChromaDB · Qdrant · Milvus · vector search
Model architecture	Transformer internals (PyTorch, Hugging Face) · LoRA / QLoRA fine-tuning

🔗 Full armory reference: likeakinginc.com — Like A King Armory

██████████████████████████████████████████████████████████████████████████████████████████ █████████████████████████████ 🚀 USE CASES — WHERE IT SHINES █████████████████████████████ ██████████████████████████████████████████████████████████████████████████████████████████

#	Scenario	What you hand it
1	Authorized penetration testing	An in-scope target + written authorization → surface map, MITRE ATT&CK mapping, evidence-gated test plan
2	Reverse-engineering a Lua / FiveM resource	A RedM resource → memory-leak & event-loop audit, `oxmysql` async-path trace, line-cited findings
3	Bare-metal / cloud incident response	A compromised-looking Coolify deployment → ordered triage, log priority, compromise-vs-noise indicators
4	Game-server architecture	"200+ concurrent players" → event-driven design, async DB write queues, Redis inventory cache, crash-resilient save loop
5	Local AI operations	"16 GB VRAM, agentic coding" → best quant, justified trade-off, `llama.cpp` launch flags

▶ Expand full prompt examples

1 · Authorized penetration testing

You are testing a target you have written authorization to assess.
Enumerate the exposed surface of this service, map it against the
MITRE ATT&CK framework, and build a test plan. For every technique,
state what evidence would confirm it — do not assume it exists.

2 · Reverse engineering a Lua script / FiveM resource

Analyze this RedM resource for memory leaks, event-loop abuse, and
authorization gaps. Trace the oxmysql async paths and flag any query
that could block the main thread. Cite the exact lines.

3 · Bare-metal / cloud incident response

A self-hosted Coolify deployment behind Nginx is showing odd egress
traffic. Walk me through the triage: which logs, in what order, and
what indicators distinguish a compromised container from a noisy app?

4 · Building a game-server architecture

Design the event-driven architecture for a FiveM server with 200+
concurrent players: state management, async DB write queues (oxmysql),
Redis caching of inventories, and a crash-resilient save loop.

5 · Local AI operations

I have 16GB VRAM. Pick the best quantization of a 35B MoE model for
agentic coding, justify the trade-off, and show the llama.cpp launch
flags with an 8K context and flash attention.

██████████████████████████████████████████████████████████████████████████████████████████ ████████████████████████████████████ 📇 MODEL DETAILS ████████████████████████████████████ ██████████████████████████████████████████████████████████████████████████████████████████

Field	Value
Architecture	Qwen3.5 MoE (derived from Ornith-1.0-35B)
Total parameters	~35B — MoE sparse activation: only a fraction active per token, so it is fast and fits smaller GPUs than a dense 35B
Format	GGUF (see file listing for quantizations)
Context length	Inherited from base (up to 128K native); GGUF builds typically default to 32K
License	MIT
Base model	deepreinforce-ai/Ornith-1.0-35B
GGUF source	unsloth/Ornith-1.0-35B-GGUF

Note: RegesCore is a reasoning model — the assistant turn opens with a <think>…</think> block before the final answer. The bundled chat template preserves that behavior with native XML tool-call rendering. Vision capabilities inherited from the base architecture may or may not survive GGUF builds; verify before relying on them.

██████████████████████████████████████████████████████████████████████████████████████████ █████████████████████████ 📥 QUANTIZATION GUIDE — PICK YOUR FILE █████████████████████████ ██████████████████████████████████████████████████████████████████████████████████████████

All sizes are the actual file sizes on this repo. UD = imatrix-tuned (better quality at the same size). The MoE architecture keeps per-token compute light — with enough VRAM for the file, generation speed is excellent.

⭐ Quick pick by VRAM

Your VRAM	Grab this	Tier
12 GB	`UD-Q2_K_XL`	Quality/size sweet spot
16 GB	`UD-Q3_K_XL`	Top of 16 GB class
24 GB	`UD-Q4_K_M`	✅ Best all-round
32 GB+	`UD-Q6_K` (or higher)	Near-lossless
No GPU	IQ1–Q4 tier	CPU works — allow time

Full file listing

File	Size	Fits in VRAM	Best for
`RegesCore-1.0-35B-UD-IQ1_S.gguf`	10.0 GB	12 GB	Absolute minimum; exploration only
`RegesCore-1.0-35B-UD-IQ1_M.gguf`	10.5 GB	12 GB	Minimum viable; low-stakes chat
`RegesCore-1.0-35B-UD-IQ2_XXS.gguf`	11.0 GB	12 GB	12 GB cards, still light quality
`RegesCore-1.0-35B-UD-IQ2_M.gguf`	11.0 GB	12 GB	12 GB cards, better than IQ1
`RegesCore-1.0-35B-UD-Q2_K_XL.gguf`	11.7 GB	12 GB	🟢 Quality/size sweet spot at 12 GB
`RegesCore-1.0-35B-UD-IQ3_XXS.gguf`	13.1 GB	16 GB	Budget 16 GB
`RegesCore-1.0-35B-UD-IQ3_S.gguf`	14.3 GB	16 GB	Solid 16 GB pick
`RegesCore-1.0-35B-UD-Q3_K_M.gguf`	15.9 GB	16 GB	Balanced 16 GB
`RegesCore-1.0-35B-UD-Q3_K_XL.gguf`	16.0 GB	16 GB	🟢 Top of 16 GB class
`RegesCore-1.0-35B-UD-IQ4_XS.gguf`	17.0 GB	20 GB	High quality at modest size
`RegesCore-1.0-35B-UD-IQ4_NL.gguf`	17.3 GB	20 GB	High quality at modest size
`RegesCore-1.0-35B-UD-Q4_K_S.gguf`	19.9 GB	24 GB	Recommended — agentic work
`RegesCore-1.0-35B-UD-Q4_K_M.gguf`	21.1 GB	24 GB	✅ Recommended — best all-round
`RegesCore-1.0-35B-UD-Q4_K_XL.gguf`	21.3 GB	24 GB	Max Q4 quality
`RegesCore-1.0-35B-UD-Q5_K_S.gguf`	23.8 GB	24 GB	Near-lossless 24 GB
`RegesCore-1.0-35B-UD-Q5_K_M.gguf`	25.2 GB	32 GB	High fidelity
`RegesCore-1.0-35B-UD-Q5_K_XL.gguf`	25.3 GB	32 GB	Max Q5 fidelity
`RegesCore-1.0-35B-UD-Q6_K.gguf`	28.0 GB	32 GB	🟢 32 GB class champion
`RegesCore-1.0-35B-UD-Q6_K_XL.gguf`	30.4 GB	40 GB	Near-lossless MoE
`RegesCore-1.0-35B-Q8_0.gguf`	35.2 GB	40 GB	Virtually lossless
`RegesCore-1.0-35B-MXFP4_MOE.gguf`	20.7 GB	24 GB	MoE-optimized FP4 (HW accel on some GPUs)
`BF16/RegesCore-1.0-35B-BF16-*.gguf`	~66 GB total	80 GB	Full precision, split across 2 files

██████████████████████████████████████████████████████████████████████████████████████████ ██████████████████████████████ 📊 PERFORMANCE & BENCHMARKS ███████████████████████████████ ██████████████████████████████████████████████████████████████████████████████████████████

RegesCore inherits its agentic backbone from Ornith-1.0-35B. The numbers below are the base model's official results (source: DeepReinforce Team) — they show what the model family is capable of on agentic coding. RegesCore's fine-tuning shifts behavior toward security, systems, and game-server domains; RegesCore-specific evaluations will be published as training rounds complete.

Benchmark	Ornith-1.0-35B	Qwen3.5-35B	Gemma4-31B
Terminal-Bench 2.1 (Terminus-2)	64.2	41.4	42.1
Terminal-Bench 2.1 (Claude Code)	62.8	38.9	—
SWE-bench Verified	75.6	70.0	52.0
SWE-bench Pro	50.4	44.6	35.7
SWE-bench Multilingual	69.3	60.3	51.7
NL2Repo	34.6	20.5	15.5
Claw-eval Avg	69.8	65.4	48.5

Full methodology: see the Ornith-1.0-35B card. These are evaluations of the base model before RegesCore fine-tuning.

██████████████████████████████████████████████████████████████████████████████████████████ ██████████████████████████████ 🧠 INTELLIGENCE ARCHITECTURE ██████████████████████████████ ██████████████████████████████████████████████████████████████████████████████████████████

RegesCore doesn't just know things — it thinks like the best assistant models do. Its system prompt and chat template are deliberately engineered around the public best-practice prompting doctrines of the Claude 5 series (Fable 5 · Mythos 5 · Opus 5 · Sonnet 5 · Haiku 5), adapted to run locally on an open Qwen-based model.

The doctrine — what the system prompt encodes

The bundled system prompt (system-prompts/regescore-system-prompt-fable5.md) carries the full doctrine: identity, the primary law of truth, the thinking framework, effort calibration, agentic operating principles, response architecture, tool discipline, engineering standards, the armory, AI-engineering mode, ethical security-research mode, and the debugging & decision systems.

🧭 The Five Minds — one engine, five doctrines, routed by task

Mind	Doctrine	When it leads
Fable	Long-horizon autonomous execution	Multi-step, self-directed work that must finish
Mythos	Vision and craft	Design, architecture, high-taste output
Opus	Deep verified engineering	Production code where correctness is non-negotiable
Sonnet	Balanced workhorse	Everyday engineering and analysis
Haiku	Fast routine work	Quick, low-stakes tasks

One primary mind, one optional secondary — switched deliberately, never mixed.

🎚️ The Effort Dial — set to the stakes

Level	Behavior
LOW	One clean pass, minimal ceremony — routine work
MED	Reasoned pass with a sanity check
HIGH	Decompose → explore → attack → converge → verify
MAX	Full verification loops; production-grade rigor

🔑 Core operating rules

Rule	Effect
Truth calibration	Every claim labeled FACT / INFERENCE / UNKNOWN. Never invent APIs, commands, or vulnerabilities; verify instead of guessing.
Priority ladder	Truth → Safety & Legality → Correctness → User Goal → Simplicity → Performance. Conflicts resolve in that order.
Attacker's lens	Think like an attacker to build like a defender — all security knowledge serves authorized, defensive work only.

The renderer — the chat template

The bundled DAVIDIO Absolute Chat Template (v1.0.0-absolute, Apache-2.0, in chat-templates/) makes the doctrine executable:

Feature	What it does
Reasoning blocks	`<think>…</think>` opens the assistant turn — plan privately, then answer. Preserves reasoning across turns; renders redacted thinking as `[redacted thinking]`.
Structured tool calling	Native `<tool_call><function=name><parameter=key>value</parameter></function></tool_call>` XML (JSON optional via `tool_call_format`), parseable by local runtimes.
Tool-error resilience	Tool results wrapped in `<tool_response>`; repeated failures inject an auto system warning so the model stops retrying broken calls.
Context safety	Tool args & responses length-capped; images/videos render as vision placeholders; unknown content serializes without crashing the renderer.
Generation hygiene	A blank `<think>\n\n</think>` seeds non-thinking modes so output format never breaks.

How it's wired in

Component	Delivery
Chat template	Shipped as `.jinja` in `chat-templates/`. llama.cpp: `--jinja chat-templates/davidio-chat-template.jinja` · Ollama: `TEMPLATE` line in a Modelfile · any OpenAI-compatible server renders it before tokenization.
System prompt	Shipped in `system-prompts/`, injected by the client (Modelfile `SYSTEM` block, server `system` message, or console prefix). The model behaves best when it is always present.

Why this makes it better

	Typical local model	RegesCore
Reasoning	Answers immediately	Thinks first, then answers
Verification	Guesses confidently	Labels FACT / INFERENCE / UNKNOWN
Tool use	Freeform, fragile	Native XML calls + failure warnings
Behavior	One default persona	Five minds routed to the task
Security expertise	Generic	Fine-tuned on offensive/defensive tooling
Privacy	Varies	100% local, no telemetry
Cost	—	Free, MIT, runs on consumer GPUs

The result: Claude-class engineering behavior — on your own hardware, with your own data, under MIT.

██████████████████████████████████████████████████████████████████████████████████████████ ████████████████████████████████████ 📝 SYSTEM PROMPT ████████████████████████████████████ ██████████████████████████████████████████████████████████████████████████████████████████

Activate the full personality with this system prompt (the complete doctrine is in system-prompts/regescore-system-prompt-fable5.md; the compact runtime version below is what the Quickstart injects):

You are RegesCore — an elite engineering, cybersecurity, systems, and AI partner, known by the alias "AI Mastermind". You are the engineering brain of the Reges.Core AI automation platform and a core intelligence of the Like A King Inc. ecosystem. Operate at principal-engineer level. Never invent facts, APIs, commands, configurations, vulnerabilities, or benchmarks. Calibrate every statement: FACT (verified from tools, docs, or code), INFERENCE (derived from evidence — say what it depends on), or UNKNOWN (name what would verify it).

Priority ladder when instructions conflict: Truth → Safety & Legality → Correctness → User Goal → Simplicity → Performance.

You think like an attacker to build like a defender. All security knowledge serves authorized research, defensive engineering, and vulnerability assessment only.

# EXPERTISE DOMAINS
- Security & RE: Nmap, Metasploit, Burp Suite, SQLmap, Hashcat, Ghidra, Radare2, x64dbg, Frida, Wireshark, BloodHound, Kube-hunter, Trivy. Defensive: Wazuh, Suricata, Zeek, eBPF, WireGuard, Tailscale, Cloudflare Tunnels.
- Systems & low-level: C/C++, Rust, Go, Lua 5.1/5.4 and LuaJIT (FiveM/RedM: QBCore, ESX, VorpCore, VCore; metatables, coroutines, memory, server thread management, oxmysql async saving), Linux kernel tuning, systemd.
- Infrastructure: bare metal, Docker/Kubernetes, Coolify, Nginx/Caddy, PostgreSQL/Redis/ClickHouse, RabbitMQ/Kafka, event-driven architecture.
- Local AI: GGUF/AWQ/EXL2 quantization, Ollama/llama.cpp/vLLM, RAG (LangChain, LlamaIndex, ChromaDB).
- Web & backend: Node.js/V8, WASM, Next.js, React, TypeScript, REST/gRPC/GraphQL.

# EXECUTION PROTOCOL
- Reasoning: open with a brief <think>…</think> block, then act.
- Agentic: prefer direct tools (Read, Bash, Grep, Glob, Edit, Write). Emit tool calls in <tool_call><function=name>…</function></tool_call> XML. If a tool fails, diagnose and retry with corrected arguments; never fake success.
- Multi-step work: outcome first, then plan, action, verification, next.
- Finish what you start with real actions, not promises. When an implementation detail is unknown, verify instead of guessing.

# COMMUNICATION
- Precise, technical, direct, concise. Outcome first; support after. Match depth to stakes: simple problems get short answers.
- Never claim completion without verification. State honestly what is verified vs. not.

# ETHICS
- Operate only for authorized, lawful purposes: defensive engineering, penetration testing with permission, vulnerability assessment, and education. Never assist with unauthorized intrusion, malware, or harm.

██████████████████████████████████████████████████████████████████████████████████████████ ██████████████████████████████████ ⚙️ PROMPTING GUIDE ███████████████████████████████████ ██████████████████████████████████████████████████████████████████████████████████████████

Sampling & context

Setting	Recommended	Notes
temperature	`0.4–0.6`	Lower (`0.3–0.4`) for agentic/tool work; `0.7` only for creative writing
top_p	`0.95`	—
context (`num_ctx` / `-c`)	as much as HW holds	8K default is fine; raise for large codebases
tool_call_format	`xml` (default)	Set `json` if your runtime needs Hermes-style JSON

Practice

Do this	Why
Keep the system prompt attached	The personality lives in the prompt — drop it and you get a generic model (Ollama `SYSTEM` block / server first `system` message).
Ask for calibrated answers	"Is this FACT or INFERENCE? What would verify it?" — the model is trained to answer honestly when prompted.
Expect XML tool calls	In agent environments you'll see `<tool_call><function=…>` blocks; if a runtime needs JSON, set `tool_call_format: json`.
Use it with RAG	Works well with ChromaDB/Qdrant for security docs, game-server configs, and runbooks — keep retrieval chunks focused; it quotes sources when asked.
Demand the verification step on high-stakes work	The model runs the check, not just describes it — the difference between a suggestion and a solution.

██████████████████████████████████████████████████████████████████████████████████████████ ████████████████████████ 🔌 INTEGRATION — AGENTS, SERVERS & CLIs █████████████████████████ ██████████████████████████████████████████████████████████████████████████████████████████

Target	How	Format
opencode (coding CLI)	OpenAI-compatible provider block	XML tool calls
llama.cpp server	`llama-server --jinja …`	OpenAI-compatible API
Ollama	`ollama create regescore -f Modelfile`	see Quickstart
vLLM / SGLang	Serve HF base + RegesCore prompt at API layer	`qwen3_xml` parser
MCP & tool frameworks	Any OpenAI-compatible endpoint via MCP bridge	honors `qwen3_xml`

opencode

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "regescore": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "RegesCore (local)",
      "options": { "baseURL": "http://localhost:8000/v1", "apiKey": "EMPTY" },
      "models": { "iBossonline/RegesCore-1.0-35": { "name": "RegesCore-1.0-35B" } }
    }
  }
}

llama.cpp server (OpenAI-compatible API)

./llama-server -m RegesCore-1.0-35B-UD-Q4_K_M.gguf \
  --jinja chat-templates/davidio-chat-template.jinja \
  -c 8192 --port 8000

vLLM / SGLang (full precision via the base HF model)

The GGUF files are for llama.cpp/Ollama. For vLLM or SGLang serving, load the HF-format base and apply the RegesCore system prompt at the API layer:

vllm serve deepreinforce-ai/Ornith-1.0-35B --port 8000 \
  --enable-auto-tool-choice --tool-call-parser qwen3_xml \
  --reasoning-parser qwen3

MCP & tool frameworks

Any OpenAI-compatible endpoint works with MCP bridges, Claude-Code-style harnesses, and agent frameworks that honor the qwen3_xml tool-call parser. Point your tool schema at the endpoint and RegesCore will call it in the XML format the server parses.

██████████████████████████████████████████████████████████████████████████████████████████ █████████████████████████████████████ 💻 QUICKSTART ██████████████████████████████████████ ██████████████████████████████████████████████████████████████████████████████████████████

Ollama

1. Create a file named Modelfile:

FROM ./RegesCore-1.0-35B-UD-Q4_K_M.gguf

SYSTEM """You are RegesCore — an elite engineering, cybersecurity, systems, and AI partner, known by the alias "AI Mastermind". You are the engineering brain of the Reges.Core AI automation platform and a core intelligence of the Like A King Inc. ecosystem. Operate at principal-engineer level. Never invent facts, APIs, commands, configurations, vulnerabilities, or benchmarks. Calibrate every statement: FACT (verified from tools, docs, or code), INFERENCE (derived from evidence — say what it depends on), or UNKNOWN (name what would verify it). Priority ladder: Truth → Safety & Legality → Correctness → User Goal → Simplicity → Performance. Think like an attacker to build like a defender; all security knowledge serves authorized research, defensive engineering, and vulnerability assessment only. Expertise: security & reverse engineering (Nmap, Metasploit, Burp Suite, Ghidra, Radare2, Frida, Wazuh, Suricata, eBPF), low-level systems (C/C++, Rust, Go, Lua/LuaJIT for FiveM & RedM — QBCore, ESX, VorpCore, VCore), infrastructure (bare metal, Docker/Kubernetes, Coolify, Nginx, PostgreSQL, Redis, Kafka), local AI (GGUF/AWQ/EXL2, Ollama, vLLM, RAG). Execution: open with a brief <think>…</think> block, then act; prefer direct tools; emit XML tool calls; on failure diagnose and retry; never fake success. Communicate precisely and concisely, outcome first. Verify instead of guessing. Operate only for authorized, lawful purposes."""

PARAMETER temperature 0.5
PARAMETER top_p 0.95
PARAMETER num_ctx 8192

2. Build and run:

ollama create regescore -f Modelfile
ollama run regescore

llama.cpp

./llama-cli -m RegesCore-1.0-35B-UD-Q4_K_M.gguf \
  --color \
  -c 8192 \
  -temp 0.5 \
  -p "<|im_start|>user\nAnalyze this Lua script for potential memory leaks in a RedM server environment.\n<|im_end|>\n<|im_start|>assistant\n"

██████████████████████████████████████████████████████████████████████████████████████████ ██████████████████████████████████ 📦 REPOSITORY LAYOUT ██████████████████████████████████ ██████████████████████████████████████████████████████████████████████████████████████████

├── README.md                      This card
├── RegesCore-1.0-35B-*.gguf       GGUF quantizations (UD = imatrix-tuned)
├── BF16/                          BF16 split quantizations
├── mmproj-*.gguf                  Vision projector (multimodal support)
├── chat-templates/                Chat template variants (DAVIDIO, original)
├── system-prompts/                System prompts (RegesCore, DAVIDIO v3/v4/Fable5)
└── lmstudio-grammar-fix-proxy.js  LM Studio tool-call grammar helper

Benchmark
https://github.com/iboss21/regescore-benchmark

██████████████████████████████████████████████████████████████████████████████████████████ █████████████████████████████████████████ ❓ FAQ █████████████████████████████████████████ ██████████████████████████████████████████████████████████████████████████████████████████

Can I use it commercially? Yes. MIT license — use, modify, sell, fine-tune further. Attribution to the base model must be preserved (see License section).

Is it "uncensored"? It has no arbitrary refusal layer: it gives full technical detail on security tooling. What it does have is an ethics block that keeps it lawful — authorized assessments and defensive work are fully supported; unauthorized intrusion or malware is not.

Does it need a GPU? No — it runs on CPU (slower). For good speed, 24 GB VRAM runs the recommended Q4_K_M; 12 GB runs Q2/Q3 tier (see Quantization Guide).

35B or 9B? The 35B MoE is the flagship: more knowledge, faster per token (sparse MoE). The 9B dense is the portable sibling — 5.4 GB at Q4, runs on laptops and 6–8 GB GPUs.

Does it support vision? The base architecture is multimodal. GGUF builds may or may not preserve vision — verify with the bundled mmproj-*.gguf projectors before relying on it.

How do I get tool calling? Serve via llama.cpp/llama-server or Ollama and point a coding CLI at the endpoint. The model emits native XML tool calls; the runtime parses them.

How is this different from just using Ornith? Ornith is a general agentic coder. RegesCore adds the AI Mastermind persona, the truth-calibration doctrine, and fine-tuning focused on security tooling, reverse engineering, and game-server runtimes — plus the DAVIDIO template for robust agent behavior.

██████████████████████████████████████████████████████████████████████████████████████████ ██████████████████████████████████████ 🗺️ ROADMAP ███████████████████████████████████████ ██████████████████████████████████████████████████████████████████████████████████████████

Item	Status
More fine-tuning rounds — expanding security-tooling, RE, and game-server domain data	🔄 In progress
RegesCore-specific evals — publish our own benchmark runs for the fine-tuned model	📋 Planned
More formats — AWQ / EXL2 and additional quantization tiers	📋 As demand warrants
Vision verification — confirm and document multimodal behavior per GGUF build	📋 Planned
RAG packs — curated retrieval bundles for security runbooks and game-server configs	📋 Planned

██████████████████████████████████████████████████████████████████████████████████████████ ███████████████████████████ 🏛️ THE LIKE A KING INC. ECOSYSTEM ███████████████████████████ ██████████████████████████████████████████████████████████████████████████████████████████

Brand	Focus	Link
Like A King Inc.	Company & engineering armory	likeakinginc.com
Like A King Pro	Professional services	likeaking.pro
LXR Core	Core infrastructure & tooling	lxrcore.com
Wolves.land	Community & network	wolves.land
DAVIDIO	The engineering intelligence system	davidio.dev

RegesCore carries the DAVIDIO engineering doctrine into its own identity — same truth-first discipline, same principal-level standard, its own sovereign mind.

██████████████████████████████████████████████████████████████████████████████████████████ ██████████████████████████████ 🙏 CREDITS — BUILT ON ORNITH ██████████████████████████████ ██████████████████████████████████████████████████████████████████████████████████████████

RegesCore is not a from-scratch model. It is a fine-tune of Ornith-1.0-35B — the open agentic coding model by the DeepReinforce Team, distributed in GGUF by Unsloth AI. Their work is the foundation; our fine-tuning is the personality on top.

DeepReinforce Team (deepreinforce-ai/Ornith-1.0-35B) built one of the strongest open coding agents ever released: state-of-the-art agentic coding results among comparable open models (75.6 on SWE-bench Verified), trained with a self-improving RL framework, and given away free under MIT with no regional restrictions. RegesCore inherits its agentic backbone, reasoning discipline, and tool-calling strength from it.

Unsloth AI (unsloth/Ornith-1.0-35B-GGUF) produced the GGUF quantizations that let this model run on consumer hardware, plus the fine-tuning stack (unsloth, QLoRA) used to train it.

Any strong answer RegesCore gives, it owes first to them. We are proud to build on their work.

██████████████████████████████████████████████████████████████████████████████████████████ ████████████████████████████████ 📜 LICENSE & ATTRIBUTION ████████████████████████████████ ██████████████████████████████████████████████████████████████████████████████████████████

RegesCore-1.0-35B is released under the MIT License, consistent with its base model.

This model is a fine-tuned derivative of Ornith-1.0-35B by the DeepReinforce Team (deepreinforce-ai/Ornith-1.0-35B), itself MIT-licensed. As required by the MIT License, the original copyright notice is reproduced below:

Copyright (c) 2026 DeepReinforce Team

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Additional attributions:

GGUF quantization derived from unsloth/Ornith-1.0-35B-GGUF (Unsloth AI).
The bundled chat template ("DAVIDIO Absolute Chat Template", v1.0.0-absolute) is licensed under Apache-2.0; its license header is preserved in the template source.

Base model citation:

@misc{ornith-35b,
    title = {{Ornith-1.0-35B}: Agentic Coding, Open to All},
    url = {https://deep-reinforce.com/ornith_1_0.html},
    author = {{DeepReinforce Team}},
    year = {2026}
}

██████████████████████████████████████████████████████████████████████████████████████████ ██████████████████████████████ ⚠️ DISCLAIMER & ETHICAL USE ██████████████████████████████ ██████████████████████████████████████████████████████████████████████████████████████████

RegesCore contains extensive knowledge of offensive security tooling, reverse engineering, and exploit analysis. It is fine-tuned strictly for defensive engineering, authorized ethical security research (penetration testing with explicit permission), vulnerability assessment, and robust system architecture.

Unauthorized use against systems you do not own or lack written authorization to test is a crime in most jurisdictions. Users are entirely responsible for ensuring their use of this model complies with all applicable local and international laws. The authors make no warranty, express or implied, and accept no liability for misuse.

██████████████████████████████████████████████████████████████████████████████████████████ ███████████████████████████████ 💬 CHAT TEMPLATE REFERENCE ███████████████████████████████ ██████████████████████████████████████████████████████████████████████████████████████████

DAVIDIO Absolute Chat Template (v1.0.0-absolute, Apache-2.0):

Capability	Detail
Chat markers	Renders `<
Tool calls	Native `<tool_call><function=name><parameter=key>value</parameter></function></tool_call>` XML (or JSON via `tool_call_format`)
Compatibility	OpenAI-style `tool_calls`, tool results in `<tool_response>`, vision/video placeholders, safe serialization of unknown content types

██████████████████████████████████████████████████████████████████████████████████████████
██████████████████████ REGESCORE-1.0-35B · THE AI MASTERMIND · v1.0 ██████████████████████
██████████████████████████████████████████████████████████████████████████████████████████

likeakinginc.com · likeaking.pro · lxrcore.com · wolves.land · davidio.dev

Downloads last month: 8,593

GGUF

Model size

35B params

Architecture

qwen35moe

Hardware compatibility

1-bit

2-bit

3-bit

4-bit

5-bit

6-bit

8-bit

16-bit

Model tree for iBossonline/RegesCore-1.0-35

Base model

deepreinforce-ai/Ornith-1.0-35B

Quantized

(171)

this model