🎯 Needle: Free, Local, Dependable 0:00
The pitch, in one breath: a free LLM that works like Jev, "so it will make no mistakes," small enough to incorporate into your software, small enough to put into hardware you build, no internet connection required (so it's private) — and free. This is Needle, Cactus Compute's on-device model, and the interview is with Henry Ndubuaku.
The through-line of the whole conversation is one idea: reliability comes from restriction. A model that can't do a million things can't surprise you — which, for automation you're shipping into real products, is worth more than raw capability.
💡 Structured Tool Calls: The Magic Underneath 0:18
The smart-home demo is the canonical example: "turn off all the lights" → Needle emits structured instructions — tool calls — for an execution system to carry out, and the lights go off. The key insight Henry stresses immediately: output quality depends on how you scope the available tools. Give it "set lights," "set temperature," and so on, and the quality of what comes back is a direct function of how carefully you defined those tools.
A more code-like example makes it concrete: a piece of software with defined actions — set alarm, set timer, play podcast, stop timer, calculate. Type "remind me to renew the passport next month" and Needle emits the instruction to call set_reminder with the right arguments. It also does structured extraction: give it a schema and a body of text ("find my notes about the dentist") and it pulls the matching fields.
🔌 Local App Integration & llm.txt 3:18
The practical scenario Andrew lays out: you're building a note-taking app in Claude Code, it offers to wire in the Anthropic API ("too expensive") or a limited-free tier — and instead you drop in Needle. "The dependable part is maybe even more valuable than the small." You know exactly what it's going to do — it's not guessing, and it also can't act as your therapist or write a novel. You hand it to Claude, and now you have no external calls and a dependable result.
The integration path is deliberately low-friction: Cactus is open source on GitHub, and to have Claude build an app with Needle you use llm.txt — "literally just copy this and give it to Claude, and Claude gets the context for how to use Needle." Everything stays contained, and the app works without even being online.
🤖 On-Device: Robot Vacuums & Hardware 5:06
What got people excited on GitHub wasn't just the software use cases — it was going beyond the computer to devices. The robot-vacuum example: put Needle on the vacuum itself, and you can tell it "clean the kitchen, not the bedroom, not the living room" — then follow up with "go to the dock," and it returns to charge. No internet call; the model runs on the device, and humans interact with the hardware the way they naturally talk.
That's the framing that matters: if you're making a robot vacuum, you take Needle, put it on the vacuum, and the device has on-device intelligence — no round trip to a cloud LLM.
🛡️ Reliability: Scoped Tools & Confidence Scores 7:12
Andrew keeps pressing the same question — "how does it not make mistakes?" — and the answer is two mechanisms working together:
- Tightly scoped tools. Needle is "designed to be customized." The description you give each tool is strict, because automation is careful setup — "you don't want it turning off the fridge overnight and having your food spoil." You can even enumerate the options (like Jev): forward, backward, left — it shouldn't go out of that scope. If you don't give it the "delete pictures" tool, it has no access to it. "Anything beyond that, it doesn't do anything."
- Confidence scores. Every response carries a confidence value (e.g., 0.97). At low confidence, Needle will sometimes refuse outright; other times it returns the result with the confidence so the developer decides — below threshold, don't execute. "If it's below this threshold, don't execute it."
📱 Phones, Laptops & "Automate Anything" 10:12
The remaining demos broaden the scope without breaking the pattern. On a phone: "create an album called weekend and move the photos from last weekend into it" — Needle extracts the tags and is ready to act. On a laptop: start a timer by voice, or "copy what's on the screen to the clipboard" instead of manually scrolling.
Henry's summary of the ceiling is deliberately ambitious: "it should be able to automate anything, as long as you scope it quite well" — control your whole laptop, given enough well-defined tools. The constraint isn't the model's ceiling; it's how carefully you define the actions.
⚖️ Needle vs Jev & the Verdict 11:42
The Jev comparison is handled with unusual candor. They share the same ethos: for practical automation, you don't need an LLM "rambling" — you need safe actions, so the model's output is restricted to selecting within a limited space (a finite set of tools, and finite options within each). Jev is "kind of a subset — strictly based on enums, the model literally just selects one of multiple choices." Needle can solve the same problem.
But they're not competition, and Henry is happy about it: "we're on-device; Jev is cloud." Needle targets much smaller devices — laptops are about the biggest — with 8–29MB models built for smart-TV remotes, smartwatches, AirPods, and the kind of kitchen speaker where "you wouldn't trust a corporation to have access to your live activities." The market is ultimate privacy: local AI for things that should never stream to a server.
💡 Key Takeaways
- Reliability comes from restriction. Scope the tools tightly and enumerate the options, and the model can't surprise you.
- It emits tool calls, not prose. Needle turns natural language into structured instructions your automation executes.
- Output quality = f(tool scoping). "A lot of the quality you get is dependent on how you scope out its characteristics."
- Confidence gates execution. Every response carries a score; below your threshold, don't execute — and Needle may refuse outright at low confidence.
- Limited capability is a feature. It won't suddenly become your therapist or control your computer — that's what "dependable" means.
- Integrate via llm.txt. Paste it into Claude Code and it builds apps with Needle, no external API.
- It's for devices, not desktops. 8–29MB models for robot vacuums, remotes, smartwatches, AirPods — ultimate privacy, never streams to a server.
- Not Jev's competitor. Needle is on-device, Jev is cloud — same safety ethos, different market, and Needle you can actually build with.
🔗 Resources & Links
- 🐙 github.com/cactus-compute/needle — Needle, the on-device model (open source, includes llm.txt)
Source video: youtube.com/watch?v=tsWOiibaaxA (sponsored by Zapier). A companion piece to the two earlier Needle deep dives — this one is the "why you'd ship it" interview.