1██████████████████████████████████████████████████████████████████████████████████████████
23██████╗ ███████╗ ██████╗ ███████╗███████╗ ██████╗ ██████╗ ██████╗ ███████╗ █████╗ ██╗
4██╔══██╗██╔════╝██╔════╝ ██╔════╝██╔════╝██╔════╝██╔═══██╗██╔══██╗██╔════╝ ██╔══██╗██║
5██████╔╝█████╗ ██║ ███╗█████╗ ███████╗██║ ██║ ██║██████╔╝█████╗ ███████║██║
6██╔══██╗██╔══╝ ██║ ██║██╔══╝ ╚════██║██║ ██║ ██║██╔══██╗██╔══╝ ██╔══██║██║
7██║ ██║███████╗╚██████╔╝███████╗███████║╚██████╗╚██████╔╝██║ ██║███████╗ ██║ ██║██║
8╚═╝ ╚═╝╚══════╝ ╚═════╝ ╚══════╝╚══════╝ ╚═════╝ ╚═════╝ ╚═╝ ╚═╝╚══════╝ ╚═╝ ╚═╝╚═╝
910███████████████████████████ T H E A I M A S T E R M I N D ████████████████████████████
11██████████████████████████████████████████████████████████████████████████████████████████
12████████████ OFFSEC · REVERSE ENGINEERING · SYSTEMS · GAME SERVERS · LOCAL AI ████████████
13██████████████████████████████████████████████████████████████████████████████████████████
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
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
██████████████████████████████████████████████████████████████████████████████████████████
█████████████████████████████ 🚀 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
1You are testing a target you have written authorization to assess.
2Enumerate the exposed surface of this service, map it against the
3MITRE ATT&CK framework, and build a test plan. For every technique,
4state what evidence would confirm it — do not assume it exists.
2 · Reverse engineering a Lua script / FiveM resource
text
1Analyze this RedM resource for memory leaks, event-loop abuse, and
2authorization gaps. Trace the oxmysql async paths and flag any query
3that could block the main thread. Cite the exact lines.
3 · Bare-metal / cloud incident response
text
1A self-hosted Coolify deployment behind Nginx is showing odd egress
2traffic. Walk me through the triage: which logs, in what order, and
3what indicators distinguish a compromised container from a noisy app?
4 · Building a game-server architecture
text
1Design the event-driven architecture for a FiveM server with 200+
2concurrent players: state management, async DB write queues (oxmysql),
3Redis caching of inventories, and a crash-resilient save loop.
5 · Local AI operations
text
1I have 16GB VRAM. Pick the best quantization of a 35B MoE model for
2agentic coding, justify the trade-off, and show the llama.cpp launch
3flags 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
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.
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.
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.
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):
text
1You 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).
23Priority ladder when instructions conflict: Truth → Safety & Legality → Correctness → User Goal → Simplicity → Performance.
45You think like an attacker to build like a defender. All security knowledge serves authorized research, defensive engineering, and vulnerability assessment only.
67# EXPERTISE DOMAINS
8- 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.
9- 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.
10- Infrastructure: bare metal, Docker/Kubernetes, Coolify, Nginx/Caddy, PostgreSQL/Redis/ClickHouse, RabbitMQ/Kafka, event-driven architecture.
11- Local AI: GGUF/AWQ/EXL2 quantization, Ollama/llama.cpp/vLLM, RAG (LangChain, LlamaIndex, ChromaDB).
12- Web & backend: Node.js/V8, WASM, Next.js, React, TypeScript, REST/gRPC/GraphQL.
1314# EXECUTION PROTOCOL
15- Reasoning: open with a brief <think>…</think> block, then act.
16- 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.
17- Multi-step work: outcome first, then plan, action, verification, next.
18- Finish what you start with real actions, not promises. When an implementation detail is unknown, verify instead of guessing.
1920# COMMUNICATION
21- Precise, technical, direct, concise. Outcome first; support after. Match depth to stakes: simple problems get short answers.
22- Never claim completion without verification. State honestly what is verified vs. not.
2324# ETHICS
25- Operate only for authorized, lawful purposes: defensive engineering, penetration testing with permission, vulnerability assessment, and education. Never assist with unauthorized intrusion, malware, or harm.
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.
1FROM ./RegesCore-1.0-35B-UD-Q4_K_M.gguf23SYSTEM """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."""
45PARAMETER temperature 0.5
6PARAMETER top_p 0.95
7PARAMETER num_ctx 8192
2. Build and run:
bash
1ollama create regescore -f Modelfile
2ollama run regescore
llama.cpp
bash
1./llama-cli -m RegesCore-1.0-35B-UD-Q4_K_M.gguf \2 --color \3 -c 8192\4 -temp 0.5\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"
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.
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 ███████████████████████████
██████████████████████████████████████████████████████████████████████████████████████████
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.
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.
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:
bibtex
1@misc{ornith-35b,
2 title = {{Ornith-1.0-35B}: Agentic Coding, Open to All},
3 url = {https://deep-reinforce.com/ornith_1_0.html},
4 author = {{DeepReinforce Team}},
5 year = {2026}
6}
██████████████████████████████████████████████████████████████████████████████████████████
██████████████████████████████ ⚠️ 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.
