Ornith-1.0 is INSANE (FREE + Local + Open Source)!

So today we're going to be testing out our NIF 1.0, which is a new self-learning local model you can use. It scores pretty well on the benchmarks. You can see some examples right here. So this is a new free local model you can use.

You can see how it compares versus Opus 4.7 here, and it's crushing on all the key benchmarks, as you can see. Now, we've already plugged it into our agent operating system, which you can see right here, and we can switch the model anytime that we want. So we can also run this with Hermes too. So if we go to Hermes, we set up a separate profile for onNIF, and it can work agentically with Hermes as well, which is pretty cool.

And you can get it for free on Olama. So just make sure you have Olama installed, and then you download Olama. Make sure you've got it open. And from here, you can plug this into whatever you want.

And you can see how to get the model. Now, if you're wondering, how does this work? What is this doing, et cetera? So basically, this is a powerful system where you can run a local model.

It comes from a company called Deep Reinforce. They dropped onNIF, and it's an open coding model. This goes pretty well on the benchmarks. If you want to see what we've built with it, here's some examples of different creations that we've made.

You can see the full gallery here, and these are all different things that we've built with onNIF. So it actually can build useful stuff, interesting things, even apps and games and tools and that sort of thing, which is pretty cool. And some nice visual stuff as well. Right, so it actually works.

You can plug it into Hermes as well. You've already seen inside the chat that we've got Hermes onNIF plugged in, and it seems to work pretty well. Now, the interesting thing about this as well is like, you can have a self-learning agent, which is Hermes agent, and then you've got a self-learning model, which is onNIF, and then you've combined them together, right? So you can kind of get the power of both just by using this system.

If you're wondering how does it score on benchmarks, so it is outperforming the GM4-31B on the benchmarks here. And if we look how it compares versus flagship models, it's not doing too badly on there. I would test this stuff out yourself. I don't really pay much attention to benchmarks, but if you want to see the benchmark comparisons, you can see them right there.

Now, what's interesting about this is it's self-improving. This is a strategy. This is the official blog from DeepReinforce. So it's a self-improving training framework that jointly learns to solve tasks and to construct the scaffolds that guide those solutions.

So it's building its own setup to get things done. So it'll roll out multiple solutions to solve the same problem, as you can see. So you've got onNIF here, you give it the task, it starts working on building the system to build it out, and then it comes with three solutions to get that completed. And then from there, it self-learns and improves for next time you use it.

So rather than relying on a fixed human design harness, it treats the scaffold itself as a learnable object that co-evolves with the policy. And basically what that means is it's self-improving and it figures itself out itself. It's a lot more independent. Now, this runs with RL, which is reinforcement learning.

And so the way this works is it gets a task, looks at what was previously used for similar tasks, looks at the task description, then generates a solution rollout. And then that's repeated over training to give it a positive feedback loop so that it keeps improving over time. So if we look at the benchmarks here, for example, and we compare it versus Quen 3.5, 3.7 max even, which is pretty impressive. I can't run Quen 3.7 max locally, but if we look at the benchmarks here, we don't need to, right?

On TerminalBench 2.1 or NIF 1.0 is outperforming Quen 3.7 max. Same for TerminalBench 2.1 on Cloud Code, SWE Bench Verified, like it's crushing on the benchmarks here. So if you're wondering, okay, how does the whole self-reinforcement learning process work? So it writes its own instructions.

That's the trick here. And it's the reason a 9B model that you can run on a laptop scores so well and better than models many times its size. So most AI coders work inside a fixed recipe a human wrote. The recipe, the harness tells the model how to solve a problem.

Look here first, try this, then try that, et cetera. And every model gets the same recipe. But if that recipe is wrong for your problem, the model is stuck with it. Whereas with this situation, or NIF would write its own recipe, which means for each task, it does two things.

First, it writes a plan. So how it's going to solve the problem. And then it follows that plan to write the actual code. But when the result gets graded, the score doesn't just teach a code, it teaches a plan too.

So both halves get improved. And then when that's trained over millions of times, the model doesn't just get better at writing code, it gets better at writing the plans that get better code in itself. So the strategy improves itself. It's a self-enforced positive feedback loop.

And deep reinforce actually calls this self-scaffolding. So basically it's a model that learns how to learn the task, then solves it. And that's why it performs so well. So here's how it works, right?

You get the task, it writes a plan, it writes a code, then it gets graded, and then that feeds back into the system. Now you might say this sounds technical to set up, but literally you just get a Llama and you use one prompt command to download it. So it's pretty simple and easy. And also you might say it's too slow, but it ran pretty well on my system as well.

And if you want to see all the demos that we created with ONIF, we've actually built out a local leaderboard. So this is ranked across the tasks I give it, and then we grade the size, who runs it, the license, how many tasks, how it's scored across each task. Obviously it's not going to perform as well as Frontier models, but this is a local leaderboard and we've separated that just to make it fair. And then we also have a main leaderboard here for Frontier models as well.

So you can sort of compare the differences and see them side by side. So everything that we've created with all of these local models, you can check out here as you can see. And you can see what we've created and how we've built with it, et cetera. But if you actually look, for example, like this landing page, pretty nice, pretty sleek when it loads up, looks super nice.

I'll perform some Frontier models on the same test. So it's pretty good. I would choose this over something new that came out, for example, like Gemma 12B, that seemed to be too slow for me to run. And also Quifos, which seems to break sometimes when I've tested it locally.

And that's a new model that just came out. Now also, if you plug this into our agent operating system, let me show you some of the systems we've built for this. So first of all, we have the local Hermes engine. This is an offline agent that you can talk to, and this is driven by ONIF, right?

So inside Hermes and the section here, we can switch to ONIF, and then we can run Hermes agent locally offline for free. We also have an agent Kanban. So what we can do is we can actually have teams of local models, like ONIF working together inside a Kanban board like this, and orchestrate them as well. You could do the same inside Paperclip too.

Then we also have a local chat system. So if you go to the local section here, we can use local models, see what they're built, save inside the workspace, preview, et cetera. But there's a lot of interesting things you could do with this around the systems that we've already created. And the benefits again are that they're free, private, fast to run, and local AI is getting better and better.

You might also think, okay, how does it compare against Queerfos, which is a new model for your inter-local AI? I mean, ONIF is designed more for agentic coding, right? Whereas for example, Queerfos is more designed for like creative writing and reasoning. And ONIF is based on the Jemma 4 and Quen 3.5 setup.

Queerfos is based on Quen 3.5 9b. Also big difference in context window here. But yeah, for ONIF, that's great for coding. That's what it's designed for.

Queerfos is more, for example, for creative writing and that sort of thing. So if you want to get all of our systems for using this stuff, you can get it inside the AI Profit Boardroom, link in the comments description. We've got the full agent OS inside there with the local engine, the full Hermes setups and systems that we have right here, and our mission control for managing all your agents in one place, plus a Kanban board where you can actually orchestrate teams of local AI agents. So feel free to get out inside our AI community, link in the comments description or go to theaiprofitboard.com.

Inside the community, you can ask questions and I answer them personally every single day. Inside the classroom, you can actually get access to all of our best training. So if you're a complete beginner, you can get the beginner to expert training here. If you want new daily updates on the new advanced stuff, you can get that over here.

And we also have the full agent operating system that's updated daily with a video tutorial, full step-by-step guide, and a zip file to get this installed. Inside the calendar, you can juggle with coaching calls, get help support in real time. Inside the map, you can actually meet people in your local area using AI agents like you. And this is all available inside the AI Profitboard room, link in the comments description or go.