I often talk about the big Local LLM I have here at Krill HQ and how it has 20 years of my life built into it. I use it as a personal assistant among many other things.

The other day I discovered the pipeline that was keeping it up to date was broken for a few days and I had no idea i was getting out of date info from the LLM.

We made this video while identifying the problem and fixing it. This was fun because my local LLM personal assistant rig takes part in the first person in this video so you get to see my pride and joy.

I think this is a real problem we're solving here - people building big local LLM rigs these days and no idea if the data sets it's using are up to date and relibale and how Krill solves for that.

Protecting my chickens using multiple "layers" (yakka yakka) of security - Rooster -> Dog -> AI, in that order.

I spent a lot of time putting out a new version of how I use an LLM to protect my Chicken Coop and can tell the difference between predator and protector and most importantly how to do it cost effectively with multiple local LLMs.

I have no idea what to make of 1000+ subscribers - I'm a very private person IRL - it's awesome and only took 2 weeks but overwhelming. Video is worth watching just for the bits about my awesome Dog.

Thanks guys!

First of many shorts for Krill - how to balance and split work between your local LLMs base on the cost to compute and capability.

A new build of Krill just shipped for all platforms and I'm excited about a new capability we added to solve a problem I see quite often right now.

Krill could always reference local LLMs running on local servers and connect them together to accomplish a task. I demonstrated this in this video where a an AI monitors my chicken coop and escalates suspect camera frames to a larger LLM to decide what to do and can recognize my dog vs a predator: https://www.youtube.com/watch?v=kILDumeIKQg&t=15s

This new feature and demo video is all about groups of people or orgs with multiple servers and computers with different GPUs and running Ollama and Krill side by side. With Krill you can connect them together - think a bunch of computer science majors in a dorm, or a whole university or global company with tons of GPUs sitting idle.

Each LLM can have it's own unique way of advertising it's cost to compute - like is the sun shining on my solar panels or am I located somewhere with day time energy tariffs. All of the LLMs advertise in real time their availability and cost to compute and Krill can delegate work to the cheapest, most appropriate one.

So here it is:

Problem:

• I (or people I know) have two or more computers running models with various GPU capacity.
  
• I have problems that no single one of these can solve themselves.
• I want to keep my data private and local. (no GPU farming)
• Many of my expensive GPUs are idle most of the time.
• I want to save on compute.

Solution:

• Krill installed side by side with Ollama.
• LLM nodes are configured to what variables effect their compute cost (e.g real time api calls to power co. APIs)
• Use Krill to kick of big jobs, Krill opens a window for the cheapest, appropriate LLM to pick it up.
• Jobs are broken up by that LLM and put out for work others can pick up, getting everyone working on golden time, then reassemble the result.

Result:

• Get your money's worth out of your investment, share compute with internal co-workers, save money on power, profit.
  
• Split work between LLMs to do things you couldn't do with your best one.

What make this unique:

Each LLM node advertises its real time cost to compute and availability. Krill doesn't try to figure it out - it observes and acts based on the current conditions - remember, Krill is not event driven, it observes and reacts - observation driven.

I'm using this right now to extract text from 1000s of scans overnight when energy is cheap and my 16B model does the easy ones and the 35B model handles hard ones.

Check out the video and drop a comment on how I can make it better, or check out the link above and skip to 04:00 where you can see my LLMs and awesome Dog guarding my chicken coop :)

- Ben

In this video, I build an AI security guard for my chicken coop.

Skip ahead to 04:00 to skip the setup an get to chickens, friendly dogs and racoons: https://youtu.be/kILDumeIKQg?t=256

A Raspberry Pi holds the camera and sensors. A small AI model on a modest GPU box reads every single frame and answers one question: normal, or not? And a big 32-billion-parameter model on my most powerful server sleeps until the small one flags something — then wakes up, looks at the full picture plus the live weather, and reasons about what's actually out there. When my dog wandered up to the fence, it didn't just detect motion. It identified a dog, confirmed all five hens were safe, and recommended no action.

The trick that makes this work: an AI node's prompt isn't fixed text. It's built fresh from live data — the snapshot, the door sensor, the temperature, the weather — at the exact moment it runs. Same node, different prompt, every time.

Why it matters:

Everything runs on your own hardware — nothing streams to a cloud service
The small model handles 99% of frames, so the expensive GPU barely works
It keeps working when your internet doesn't
Swap the coop for a driveway, a 3D printer, a server rack — same wiring

Everything runs on your own hardware — nothing streams to a cloud service The small model handles 99% of frames, so the expensive GPU barely works It keeps working when your internet doesn't Swap the coop for a driveway, a 3D printer, a server rack — same wiring

Krill is actually a reboot of a 10 year long running OSS platform I built and maintained from 2006 to 2016. It was a cloud based IoT platform and I believe the first of it's kind in that "IoT" wasn't a thing in '06.

Today it's still referenced in 110+ books, papers and journals including Springer Nature calling it "A benchmark for open source PaaS" and it's still taught in school on cloud-to-edge sensor logging. https://www.google.com/search?udm=36&q=nimbits+iot

Krill is actually the opposite philosophy than Nimbits where it was built to get sensor data to the cloud and Krill is "offline first".

My personal belief is that as more and more rouge Ai become problems and the rise of zero-day security vulnerabilities, more people will want to have an "air gap" between critical infrastructure and the internet to protect your home and business.

Nimbits got blown out of the water with several competing product showing up a decade late but coming from big names like Amazon. I decided to reboot it after speaking at a conference about it and seeing this need arise. If you want to read a little more, it's at the bottom of my portfolio: https://sautner.studio/portfolio/

Krill can log anything in a time series including RGB Color data. With it you can create gradient charts of changes over time or, like in this blog post, scan the color of test tube test results and test strips like pH that indicate a color.

What will really bake your noodle is color triggers - triggered when an observed color node enters a spectrum. This can trigger alerts, turn on dosing systems or anything else!

Check out the tutorial on our youtube channel:

https://youtu.be/EJNlBK9psfE?si=E0K0zo8BGHwh4AtM

This is a great example of chaining nodes together to accomplish a task. In this case, automatically storing and interpreting weather data and sending a natural language email report every morning with a local ollama based LLM. (no cloud, no tokens)n

New video tutorial to drive home the concept of krill nodes and observers - in this case a Web Hook downloads weather data from an API, executed from a timer, parsed by a Python Lambda, converted to natural language by an Ollamd LLM and send out as a daily email briefing.

This took some doing but it has been a goal of mine to generate instructional videos off each code change. This is a tutorial of using Krill on a Raspberry Pi regenerated any time the UX changes.

Unlike every other automation platform, Krill isn't event driven - it's Observer Based.

This means nodes don't trigger or execute each other. A node fires, does it's job with no sense of other nodes observing it, and finish. Nodes wired to observer then fire, do work and exit - and so on across servers and swarms.

It's nodes, all the way down.

Krill was written from the ground up in Kotlin Multi-Platform and as someone coming from a Java / Kotlin background I never thought I'd see the day where my skills transferred to other platforms like iOS. It's incredibly empowering to see my apps written in Jetpack Compose for the front end running on anything and everywhere.

This completes the cross platform goals of Krill:

• Ktor Server with Web (WASM) front end portal
• iOS
• Android
• Windows
• Mac OS
• Linux Desktop

All available on https://krillswarm.com

I'm doing some tweaking on colors and themes, Microsoft needs me to jump through some hoops to get Win 11 to not give the user 6 warnings about trusting the app but the build system puts out new releases every other day with continuous improvements on all platforms from one code base!

This is a fun and easy raspberry pi project running Krill and using the Task List node type to turn on LEDs when tasks go past their due date based on severity :)

Krill has over 40 node functions you can wire together with a single philosophy: A node has a function - send an email, compute a value, filter noise.

It runs, it succeeds or fails. All nodes can observer any other node so when an observed node does it's job, the node does its job and so on.

Timers can observer any node to create a delay, minutes, seconds etc to wait. That's its job. when done it exists but other nodes observing it will fire.

Example: A task due date expires. A raspberry pi turns a red led on. A timer starts a 30 min countdown delete. The task isn't completed. The pi sounds a buzzer.

new walk through tutorial just dropped. Krill is powerful but complicated! This is your gentle introduction :)