LFM2.5-2.6B: New FREE Local AI 🤯

**Julian Goldie** (0:00)
We may have just found the fastest local and best model with Hermes agent that you can run an actual setup. So I've been testing out LFM. It just dropped today's LFM 2.5, 26B. And it is carefully designed for device and ultrafast server-side deployments. This means it's basically really fast. It also has memory footprints, and it's been trained on Hermes as a harness. You can also run it locally, and it's pretty easy to set up as your local agent, and then you could plug it into your harness. So for example, we've got Hermes agent running with LFM. So far, pretty impressive as it goes performance-wise. Now, you can see how it performs on the benchmarks. For me personally, I like to test this off myself. But from what I'm seeing so far, it's actually faster than Gemma 4 and better than Gemma 4 And I'll show you some examples in a minute in terms of what it can build and how it works. Now, the great thing about this is that we can run it for free locally inside Hermes. You might say, why would you want to run this model inside Hermes when there's so many local models? Well, one of the best things about this is that it's literally trained for Hermes Agent. So they've trained it inside the agent harnesses people use. If you actually look at the demo video, it is using Hermes Agent as the actual training system. So you can see, for example, add four stages of post training. Now, I am not 100% an expert on this, but basically it runs through the four stages, which are SFT, expert specialization, multi-domain on policy distillation, and agentic RL. Again, do I know what all of those things mean? Can I explain it to you in a simplified way? No, I want to be 100% transparent with you. But I will say that it's basically designed for agents. So the last stage of post-training is multi-turn agentic RL through Pi, Hermes, agent, and OpenCore. This is the important part, because if you want to run a free local model that's actually decent, that's actually good with Hermes agent, this is one of the best ones you could use. Also, this would be fantastic for running as a sub agent to actually get stuff done. When I've been testing it over here, it's pretty good, it's pretty fast, and it actually responds intelligently. And I'll show you why that is as well. Now, this is designed for high-volume agentic work. One of the things that I'll say here is like when I run a model locally, typically with Hermes, it slows my whole setup down to a ridiculous rate. With this whole system, it was way faster, and also we can just get the model here. You can also see that it's designed for deploying agents everywhere. So it's one of the best models that you could run, for example, even on like mobile devices. I think that's what they're getting at here. Now, you also see here, for example, one of the benefits is that when you're running local agents, it's private, right? So when you use a local model, it's not sending your data to the cloud. Whereas, for example, you look at a lot of the models out there, they were actually decent APIs for Hermes. Most of them send your data to the cloud because they're cloud based APIs. And also you're limited in terms of resources because it's a paid API. LFM 2.5, 2.6b is actually performing pretty good on the benchmarks, and it's fast and it's local. So let's test it out here. For example, if we run it with a skill like forward slash learn, and then we'll give it a guide to learn from, we'll just see how it performs for tool use. So plugged in the command right there. And whilst that's running in the background, let's talk about the system. Now, actually Ox Zero posted a really good tweet about this, and they basically said, best model for your local hardware, 8 gigabytes, trained in Hermes, trained on a ridiculous amount of tokens, and can navigate phones, computers, and other things.
So if we test it for tool calls here, you can see it says, the skill has been successfully learned. So it can call tools, it can create skills, and it can search the web using this API.
So basically what it will do is use the built-in API which is Firecrawl, and then it searched the web, looked through this guide, created a skill locally about it, and we've done that with three models.
So it's actually agentic, it's actually useful, and it's pretty fast.
Plus it didn't affect any of my setup. It was really, really fast to run and not slow at all. Now, you don't just have to use this with AI agents. So you could actually go over to a local engine, like we've built out this custom local engine here. We can switch between the models, we actually plugged in Maple, and then we can code directly inside here, and we can preview what we've built once it's created, and everything gets saved inside the workspace. But whether you're coding with it locally like so, or you're using it agentically inside Hermes, you can still use this and get the most out of it. You can have it working in both ways. Also, the great thing is this can plug into our memory system. So we have Obsidian set up here. We could use Hermes agent with Obsidian and with LFM. So let's try this. I'm going to say, check my Obsidian memory locally, and then give me some SEO keyword ideas for content I should create in the future. And let's test how it performs when it comes to tool calling with memory. It's already pretty good at using the skills inbuilt to Hermes, like learn is already pretty fast. It's free to use as well because we're running it locally, and also it's private and we can switch your Wi-Fi off or we could go on a plane and still use this without Wi-Fi. So now it's looked through our memories, found some relevant keywords, for example, like Quen Agent OS Setup Guide or Quen 3.8 Max Agent OS, Hermes Quen Integration Guide. So these are very personalized keywords based on our Obsidian memory. It actually came back pretty quickly as well, and it works quite nicely. The other cool thing about this is you can use it for frontier builds. So we could use something like, for example, Grok Build as the brain of the engine, and then we can delegate subtasks directly to LFM for like the grunt work, for the work that takes up a lot of tokens, but doesn't need a frontier brain. And so in terms of the old way versus the new way, before every message was a paid API key, all of your data went to the cloud.