My Private Security Partner: Demystifying Ornith 1.0

It's been a while since I was looking for myself a genuine pentest companion since the birth of Local LLMs, and I have been seeing all kinds of Local LLMs come and go. But since nobody like myself owns heavy hardware to run gigantic 100B+ open-weight models like GLM 5.2, DeepSeek, Kimi K3 etc, we have to rely on cloud models like Claude, GPT, Gemini, OpenRouter, just to name a few. But there comes issues subscriptions, token limitations/expiration and privacy but mainly privacy since nobody wants to send their own or a client's data to cloud servers just to train their models.

Then there come Local LLMs, the bigger the model the bigger the hardware it's gonna cost you (mostly).

I always try to give ~1–2 hours daily on X, not for doom scrolling (for that I have Insta XD) but just to keep pace with AI. Always learning new things on X, staring new repos in my Github arsenal. And there I met my partner in crime Ornith, which got my attention with its high benchmark scores, beating models 4x its size.

Whenever I read a blog or watch a YouTube video explaining how to integrate Local LLMs with MCPs, they always go with Qwen models — which I tried via LM Studio and Llama.cpp with ClaudeCode, and it always caught itself in a loop after a while.

And why not Ollama :| Ahhh, don't get me wrong i like CLI tools so much but, I don't know why, I just like LM Studio/Llama.cpp better, maybe because it's better in many ways, and it's not just me, you can find more articles related to that matter.

I have read many comments related to Ornith-1.0–9B, BUTTTT remember, this is just a 9B parameter model and is not trained for cybersecurity tasks. It's not gonna blow your mind away, and if you have the budget, go invest in elite hardware (Mac Mini M5 Pro — 32GB, etc.) to at least run 35B models, which will be much faster and generate more tokens. Or, in the next blog I'll explain how you can quantize a big 35B parameter model on limited 8GB VRAM.

Summary

I tried different models from Ornith's family, a 9B and a 35B also Unsloth's trained Ornith as well for more agentic tasks, and both perform well enough to be included in a list of local LLMs. They can become your companion in a tight situation, but remember, human intervention is always needed, as this model isn't trained on cybersecurity tasks. Maybe in the future someone can train these models on security or bug-bounty datasets so they perform much better on targets. But somehow I managed to pull out some good stuff by adding some skills in the agentic tools like (OpenClaude and OpenCode) by solving some CTFs. I challenged the model in three categories (web, mobile, and reversing), and it held up just fine — obviously if you compare it to the big DeepSeek and GLM it's not good enough, but I'm talking about the tight environment where maybe your subscription has expired, or you have a privacy concern, etc.

Now the TECHNICAL LAYERRRR……..

Structural Analysis of the Ornith 1.0 Model Family and the Self-Scaffolding Mechanism

The Ornith 1.0 model family, released by DeepReinforce in June 2026, presents an alternative approach to executing multi-step autonomous tasks. Distributed under the permissive MIT license with no regional restrictions, this model family spans four sizes: a 9B Dense model, a 31B Dense model, a 35B Mixture-of-Experts (MoE) model, and a 397B MoE flagship.

Standard agentic architectures typically rely on static, human-engineered wrappers to manage step-by-step execution (such as LangChain or custom ReAct patterns). While these hardcoded harnesses work well for pre-defined scenarios, they're rigid — when a task hits an unexpected compiler error, a network timeout, or a changing tool schema, these static harnesses often fail, causing the agent to stall or loop indefinitely. If that sounds familiar, it's basically the exact failure mode I ran into with Qwen looping on me earlier in this post.

Ornith 1.0 addresses this limitation through a self-scaffolding training framework. Using a two-stage reinforcement learning loop, the model is trained to jointly optimize both the core solution and the execution harness itself. Instead of relying on rigid, pre-configured prompts, Ornith generates custom execution scaffolds — often formatted as executable code blocks — tailored to the specific context of the task.

To prevent the common pitfall of "reward hacking" — where reinforcement learning models find shortcuts to pass unit tests or validate output schemas without actually fixing the underlying code — Ornith uses a dual-safety structure. This design couples a frozen LLM judge with a deterministic runtime monitor, separating the evaluation environment from the model's internal generation steps to ensure logical consistency.

For local deployments, the model exposes its internal thinking steps in a separate <think> field, which is parsed by compatible local APIs before generating the final code block output.

Benchmarks and the Quantization Performance

The Ornith-1.0-9B model performs competitively on standard programming and terminal execution evaluations compared to both the base Qwen models and other open-source alternatives. It scores well on SWE-bench Verified and Terminal-Bench 2.1, indicating that its agentic capabilities match or exceed several larger baseline models.

To evaluate scaling behavior, the Ornith-1.0-35B MoE variant presents a highly capable mid-tier alternative that can run on upper-tier consumer platforms with appropriate quantization. When compared head-to-head with the base Qwen3.5-35B-A3B using the BenchAlign v5 evaluation framework, the benefits of Ornith's self-scaffolding training become apparent.

While these scores show that Ornith-1.0 is highly competitive in its size class, real-world testing reveals a more nuanced picture. In WebBrain's browser-agent planner evaluations — which measure first-turn tool calling and routing discipline on tasks outside the model's core programming training — the Ornith-1.0-35B model scored an exact first-call match of 21/100, outperforming Gemma 4 31B (19/100) and Qwen 3.6 35B-A3B (18/100). However, its tool-call parsing rate was slightly lower (88/100 vs. Gemma's 95/100), and its overall alignment with Claude Sonnet came in at 71.0% compared to Gemma's 77.0%. This suggests that while Ornith's structured tool-calling is highly effective for strict API mappings, it may fall back to natural language responses or show reduced flexibility when confronted with highly ambiguous, non-coding prompts.

Read that gap the way I read it: the benchmark numbers tell you Ornith is a strong coder, not a strong open-ended planner. Keep that distinction in mind before you hand it something loosely defined and walk away.

Practical Cybersecurity Workflows: CTF, REversing, and Agent Integration

The primary value of Ornith 1.0 within offensive enclaves is its ability to serve as a fast local companion during isolated assessments. Because the model hasn't been explicitly trained on proprietary cybersecurity exploit payloads or bug-bounty data, human intervention still needed to guide its outputs. But by hooking the model's local endpoints into specialized developer frameworks (such as ClaudeCode and OpenCode) and adding skills like Claude bug-bounty hunter etc, security practitioners can automate a variety of complex tactical tasks.

This is exactly the slot Ornith filled in my own setup. I run an agentic security stack on a Kali WSL box — I call it RAPTOR — built around a custom local MCP layer and OpenCode. Ornith slots in there as the offline fallback: when I don't want a target's data anywhere near a cloud endpoint, or when I'm simply between subscriptions, I point RAPTOR's model config at Ornith and keep working. No workflow change, no re-tooling, just a different brain behind the same harness.

Solving Capture the Flag (CTF) Challenges

Security professionals can run local instances of Ornith-1.0-9B and 35B inside unified agent environments to automate the discovery and extraction of flags in CTF exercises. By defining custom execution interfaces for the agent, the model can help analyze vulnerabilities across domains which i have tested:

Web Exploitation:

The model parses local source files, identifies missing input validation, and drafts custom Python payloads to confirm vulnerabilities. It also analyzes the terminal output from those scripts to iterate and bypass further filters. One thing I noticed about this model is that it browses target URLs with ease over a Playwright headless browser, where other local LLMs were struggling with timeout errors. I tested this mostly on web applications, and it performed well.

Android Exploitation:

The model reviews decompiled Android manifest configurations, network security parameters, and Java code files to identify local storage leaks and hardcoded keys.

REverse Engineering:

The model reverse-engineers code efficiently, using tools like objdump, strings, and xxd, while explaining functionality step-by-step and keeping a running to-do list as it works.

Screenshots comparing Deepseek vs Ornith results.

Network Exploitation:

I didn't have time to test network in-depth, but it was a bit rough though, but the 35B model performs a bit better (full testing is required). so, I tried it on one of Hackthebox machine, and it perform decent. it didn't find any flag, but it will help in achieving the small tasks while maybe you do other reconnaissance or exploitation: for example, enumerate shares, map the network with nmap scans, perform simple attacks in AD (haven't tried).

Threat Hunting and Local Log Analysis

Threat hunters can leverage Ornith's large context window to analyze raw system, proxy, or firewall logs safely offline. Analysts can paste raw log segments directly into the local context and prompt the model to identify indicators of compromise, suspicious user-agent strings, or brute-force patterns. Once an anomaly is identified, the model can translate the behavior into structured detection definitions, such as Sigma or YARA rules, without ever uploading internal network logs to a public cloud system.

Below are the examples where i asked the model to analyze the .cap & .pcap files from tryhackme.

Quick Takeaways — Who Should Actually Reach for Ornith

• Air-gapped or data-residency-sensitive engagements (banks, government, anywhere "we sent logs to a third-party API" is itself a finding)
• Web CTF and bug-bounty recon, where its Playwright handling beats other local models, I've tried
• Offline triage — log parsing, IOC spotting, first-pass Sigma/YARA drafts — when you can't or won't touch the cloud
• NOT your go-to for open-ended AD privesc chains, novel exploit chaining, or anything needing genuinely current threat intel — that's still DeepSeek/GLM territory when you have the access or the budget

Conclusions

The Ornith 1.0 family provides a capable open-source options for organizations looking to deploy local, private automation workflows. Its self-scaffolding training approach helps bridge the performance gap between small, local models and larger cloud-hosted platforms, making it a valuable addition to secure environments. It's not replacing my daily driver, and it's not trying to — it's the model I trust to keep working when the cloud isn't an option or going on a client's engagement, and for a 9B parameter dense model that's a genuinely good place to be.

If you're building out your own local/offline agentic stack for security work, that's exactly the kind of thing I'll keep writing about also i will be testing and posting more models to check which one is better — stay tuned.