frontpage.
newsnewestaskshowjobs

Open Source @Github

fp.

Show HN: Needle2: 14MB agentic LLM for phones, wearables, smart home and robots

https://cactuscompute.com/needle
66•HenryNdubuaku•4h ago•40 comments

Show HN: Higher-dimensional lattices unfolded into the 2D plane

https://number-garden.com/?@THLP@
5•unitX•4d ago•1 comments

Show HN: My local climbing gym from photogrammetry

https://kmcheung12.github.io/climb-preview/tour/ae43c6e5
2•a_c•38m ago•0 comments

Show HN: Ante, a coding agent in a single binary that runs offline

https://github.com/AntigmaLabs/ante
116•ubermon•6h ago•71 comments

Show HN: Voice driven murder mystery, Interview AI suspects with your voice

https://www.whodunnitai.com/
188•MrRowTheBoat•18h ago•81 comments

Show HN: A tiny LLM running at 21,000 tok/s on a $250 FPGA (Live Demo)

https://www.mikeayles.com/blog/on-chip-llm-kv260/
38•mikeayles•10h ago•10 comments

Show HN: PicPocket – Dedicated 'chats' for photo-sharing (share to organize)

https://picpocket.io/
4•amr_shawky•6h ago•0 comments

Show HN: A Project Oberon System version running on RISC-V instead of RISC-5

https://github.com/rochus-keller/OberonSystem/tree/op2-rv32
118•Rochus•1d ago•19 comments

Show HN: 100% native Swift harness (NOT Electron)

https://github.com/Lore-Hex/QuillCode
10•ljlolel•8h ago•3 comments

Show HN: Design Engineering, as a Service

https://designshippers.com/?0
9•krm01•9h ago•3 comments

Show HN: Neolabs.fyi – 100 new AI labs by research area, valuation, and more

https://neolabs.fyi/
7•polyphilz•7h ago•2 comments

Show HN: DocSift convert a PDF once, give the model only the passages it needs

https://github.com/anishmoncivarghese/docsift
3•anishvarghese•8h ago•0 comments

Show HN: I made alchemical-cosmological PCB badges

https://github.com/KaiPereira/Alchemical-Cosmological-Badges
21•kaipereira•5d ago•3 comments

Show HN: Bio Tools – install drug design tools easily

https://github.com/David-OConnor/bio_tools
2•the__alchemist•6h ago•0 comments

Show HN: Slashscore, an open developer graph built from public GitHub activity

https://www.slashscore.com
2•wingravity•6h ago•2 comments

Show HN: PrivateRedact – Offline PII redaction with a local LLM, no cloud

https://github.com/monjurulkarim/privateredact
3•rajubuet24•6h ago•0 comments

Show HN: My math notes for anything that touches ML

https://github.com/publications-and-more/pub
3•Amlal•6h ago•0 comments

Show HN: Vocal Slice – cut audio by selecting text, fully on-device

https://vocalslice.com/
2•terranivium•6h ago•1 comments

Show HN: filebouncer - npm package for detecting suspicious uploads.

https://github.com/Ramzi-Abidi/filebouncer
2•ramzi-abidi•6h ago•0 comments

Show HN: Self-hosted universal context layer for Mac

https://github.com/Rafaelpta/litepipe
2•rafaepta•6h ago•0 comments

Show HN: Watching browser fingerprinting calls via Chromium's Blink layer

https://kameleo.io/blog/this-is-the-closest-well-ever-get-to-reverse-engineering-anti-bots
9•brnbs•12h ago•0 comments

Show HN: Issue Apple and Google wallet passes from Node.js

https://github.com/getpassmint/passmint
5•alexpate•13h ago•0 comments

Show HN: TickClip – An AI shopping agent that can recommend not buying

https://www.tickclip.ai/
2•tickclip•7h ago•3 comments

Show HN: GlyPho – Generate editable SVG families from prompts

https://www.glypho.app/
4•shenyi•7h ago•0 comments

Show HN: Airy – Free, fast, and simple voice content creation

https://airy.so
43•login588•1d ago•16 comments

Show HN: Hawser – sign, notarize, DMG, auto-update and license a Mac app

https://hawserkit.com/
2•yaveez•8h ago•0 comments

Show HN: Edgi – Letterboxd or Strava for your brain

https://app.edgi.tv/
4•jshapiro•9h ago•0 comments

Show HN: gbx -- manage a fleet of git repos with a TUI

https://github.com/deemson/gbx
2•deemson•9h ago•0 comments

Show HN: Online Speedometer

https://kmspeedometer.com/
3•artiomyak•9h ago•0 comments

Show HN: Today's cities on a globe of Earth's tectonic past and future

https://douwe.com/projects/tectonic_globe
35•dosinga•1d ago•9 comments
Open in hackernews

Show HN: Needle2: 14MB agentic LLM for phones, wearables, smart home and robots

https://cactuscompute.com/needle
66•HenryNdubuaku•4h ago
Hey HN,

Henry from Cactus here!

We previously released Cactus Needle, a 14MB agentic LLM for tool call, device use, and structured extraction for phones, wearables, smart homes, small robots and microcontrollers. We got really great feedback here, and have now incorporated the suggestions to release Needle 2.

The whole model is a single 14MB binary that runs a full session in 28MB of RAM; 45m parameters at 2bit compression. Needle hits 500 tokens/sec decode speed on a Raspberry Pi 5, sits between 400-1,500 tokens/sec on VR devices like Meta Quest 3S and Apple Vision Pro, and ranges 300-700 on sub-$200 phones such as the Samsung A-Series.

On the tool call and mobile device use benchmarks, Needle 2 trades wins with closest small models like LFM2.5 230M and Apple Foundation Model, at 5x to 70x smaller, both at f16 vs Needle 2 at 2bit. Needle is based on Simple Attention Networks from our paper (https://arxiv.org/abs/2607.18363).

Edge AI has lately meant Macs and PCs, but that is just 1.5 billion of over 21 billion connected IoT devices in the world today, and in emerging markets most phones ship under $200, no NPU, cheap GPUs. These include budget phones, Raspberry Pis, microcontrollers, wearables, small robots like Reachy Mini, and connected home devices.

A conventional transformer of Needle's width and depth spends 164 MFLOPs per token, and even one squeezed down to Needle's parameter count spends 87, Needle spends 70. Even on a high-end phone, an always-on assistant lives inside a power budget; every MFLOP is milliwatt-hours, and Needle spends 7x to 85x fewer of them per token than the smallest performant LLMs. More about the architecture in the link.

When we structure intelligence for consumer devices as functions with typed parameters, the only hard part is mapping a messy sentence onto them; which function, with which values. Our research found that when framed that way, the problem needs no world knowledge and no open-ended prose, which is why 45M parameters suffice.

Needle 2 expands to structured extraction where the schema can be passed in-place of tools and the model returns structured output. You can use Needle as a text-classification model with an enum field, as a summarization model by providing a schema that extracts key fields, everything but free-range decode.

Every product has its own tool vocabulary and fine-tuning needle helps it achieve frontier-level performance on custom tasks, so using the python package (https://github.com/cactus-compute/needle), Needle can be fine-tuned Needle on a Mac/PC in minutes to a few hours, with automated data-generation pipeline, just pass a couple samples.

Nonetheless, every response carries a learned confidence score based our Cactus Hybrid technique. If above your threshold, act, below it, escalate to the cloud or bigger model. Combining Needle 2 with a private DeepSeek-v4-Flash deployment works particularly well for enterprise-level tasks at barely any cost, we can help with this setup.

We have put a lot of thoughts into Needle 2 but might still be missing quite a lot, please use the playground in the provided link to test Needle and share your thoughts, always appreciated!

Comments

tolugenius•1h ago
This is really cool, I'm curious how much knowledge can their be in smaller models? It seems the current trade off is you need sizeably larger models for more performance but I'm curious if in your work how far this is true, as edge ai is really what needs to get better before physical ai can take off (my two cents).
msdz•1h ago
I imagine at such a low parameter count, there would be little to no world knowledge whatsoever, and the entire focus is on getting the structure of tool calling etc. right…?

But yeah, in terms of “physical” AI, robotics definitely comes to mind for me as well, where tool calls/structured “device” use in a “realtime”/edge application are highly beneficial (if you wanted to go with LLMs), but beefy hardware can’t be easily used.

Tiberium•1h ago
Funny result from the web demo. I'm well aware that it's an extremely small and, well, stupid, model, but even so:

Query: HN

Result:

{ "function_calls": [ { "name": "lock_door", "arguments": { "door": "front door" } } ], "reasoning": "User wants to lock the door. No specific door mentioned, so use 'front door' as default.", "confidence": 0 }

I'd expect it to at least ignore (call no tools) for the queries that it doesn't understand. And it seems like it does do that, just not consistently.

jszymborski•1h ago
no, this is the appropriate response to hearing the words "HN" :P
Schiendelman•
1h ago
Was that the first message you sent it?
yoavm•53m ago
The website says the model is for "tool calling, device use, and structured extraction". Your example just doesn't seem to be very relevant. FWIW, it did a pretty good job for tool calling when I tried it, and I think it could be pretty nice to have this running on locally and integrate with Home Assistant.
evmaki•42m ago
False positives are definitely relevant and worth measuring - natural language interfaces always have a discoverability problem, i.e., users not knowing what actions the system does and does not support. If the frontend of that system lacks the ability to reject unsupported commands, weird stuff happens.

Nonetheless, this is very cool work! If I can offer a small suggestion to the team at Cactus, it would be to evaluate your releases on some usability criteria (including false positives). Any serious integrator or adopter of these models would want to have that information available.

jdknezek•36m ago
> "confidence": 0

OP and the linked page talk about the confidence score and using it as an action threshold, so it looks like an appropriate total response to me.

evmaki•24m ago
Right, but that's not the same thing as reporting a benchmark across a test set. It doesn't help me determine how well the model does across a decently-large sample size of commands. It doesn't tell me with what reliability the confidence will be below a given threshold when it should be, above that threshold when it should be, etc.
HenryNdubuaku•20m ago
Thanks, noted!
petu•39m ago
"confidence": 0, so I guess you could threshold it
hmokiguess•35m ago
yeah I got the same, almost like its biased heavily towards that as the 0 ranking -- my prompt was just the word 'potato'
arthuqa•50m ago
That's really cool - I was already thinking of compressing `functiongemma-270m-it` down to 1-2 bits so it would work flawlessly in the browser. Your `Fine-tuning` feature is even much more convenient.
HenryNdubuaku•38m ago
Thanks, give it a splin!
dofm•47m ago
Naïve and clumsy question: how would you pair this with speech-text-speech stuff, wake words etc.? Are there good examples of this for a Pi 5?

The demo is super — I'm just having trouble seeing the whole picture for e.g. a screenless device.

ETA: pun not intended

HenryNdubuaku•36m ago
Users often stack a transcription model on top to get the voice prompt, then decode to actions. Think of Alexa and Siri.
dofm•17m ago
Thank you.
nater5000•36m ago
The best entrypoint is Home Assistant: https://www.home-assistant.io/

That will get you a lot further than what you're asking, but if you dig a bit through Home Assistant features, resources, etc., you may find the current "best" answers to your questions.

If you want a quick answer: Whisper is a good open-source speech-to-text model which comes in a variety of sizes (https://huggingface.co/openai/whisper-tiny). You can definitely get something like this running on a Pi 5. There are plenty of other STT models out there, some of which are built specifically for this context (again, see the Home Assistant stuff), but Whisper comes up a lot as a good default choice.

So with something like Whisper, you could just have a simple script which is constantly listening to a rolling window of audio and transcribing it. When the transcription includes a key phrase, you can pass the rest of the transcription to Needle2 (or anything else for that matter). From there, you take the results and execute the necessary tool calls.

There's a bit more to all of this to make it work smoothly, but fundamentally this is all there is to it. All this would work very fast on a Pi 5 (although I wouldn't expect the results to be particularly good without some serious hand-crafted logic, fine-tuning, etc.). If you want to mess around this stuff, handing all of this to Claude, Codex, etc., can get you something spun up and functional very quickly.

dofm•21m ago
This is a very responsive answer, thank you so much. (I'd assumed maybe Whisper but the wake word "loop" detail there is illuminating.)
varispeed•44m ago
What is the difference between this and random sentence generator?
HenryNdubuaku•36m ago
Random sentence is not a function call.
actionfromafar•35m ago
Ask it to lock a door for instance. It seems to convert simple instructions to reasonable tool calls. Check its confidence score.
minimaltom•37m ago
Was really cool to see yous use Engrams to cut down compute!

Given its basically an O(1) lookup with disk space being the main constraint, I was curious if you've tried ablating engram layers and sizes across your setup?

Also, why mHC over attention residuals?

HenryNdubuaku•33m ago
Yes, we ablated Engrams rigorously and found that it returned world knowledge like FFN without without compute expenditure.
minimaltom•21m ago
What about mHC? I'm surprised it helped with such a small compute budget.
nater5000•27m ago
This is cool. I definitely think the "micro" sized LLM space is underappreciated, so it's always good to see work like this. I foresee a paradigm in some contexts where you have a hierarchy of LLMs, with more competent models actively training smaller models to solve specific tasks very efficiently, and something like this could be the smallest layer in that stack.

With that being said, the web demo is not particularly impressive. It really doesn't like anything I throw at it. I'm fine with accepting that fine-tuning is the solution to this, but I wonder if there's anything to gain from a bigger model? I know it's completely counter to the whole point of this, but a 14MB binary using 28MB of RAM seems unnecessarily small and pretty arbitrary.

Like, what does a 28MB binary get you? Or a 140MB binary? Or a 1.4MB binary? I'm guessing the choice of 14MB came from minimizing the size as much as possible while meeting certain requirements/performance expectations, but even a Pi 5 has plenty more room to spare. Curious if there's a good explanation for this (which I may have missed in my skim of the post).

HenryNdubuaku•20m ago
So, its not a general language model, focused on tool call strictly for tiny edge-devices. There are solutions everywhere for high-capacity devices, Needle is for sub-$200 devices.
grenli•27m ago
The learned confidence gate is the crucial piece for a 14MB action model. On ambiguous requests such as the HN example, what calibration target decides between abstaining locally and escalating to the cloud?
HenryNdubuaku•15m ago
around +60% confidence threshold is cool from experiments, the problem is that you gotta test on your own workload, no existing benchmark could honestly paint the full picture, so we exposed the confidence threshold for everyone.
redrix•26m ago
This is cool!

While most of the industry focuses on the frontier of “intelligence” (function), a release like this represents the frontier of the other end of the spectrum (form).

Both are important if we ever want to see “Opus-level” capability running locally on commodity machines in the future.

HenryNdubuaku•24m ago
thanks!
ianseyler•25m ago
I’d be interested in attempting to run this in a network- enabled 32MiB RAM microVM.
HenryNdubuaku•24m ago
Thanks, how can we help?
hgoel•15m ago
Makes me think of the demo from some time ago where someone got a ~29M parameter model running on an esp32. I wonder what kind of throughput this could get if a handful of esp32s were strung together...

Edit: I have a pile of d1 minis, but not much time.

forsalebypwner•4m ago
They mention that this specific model is able to run on an ESP32-S3, or an ESP32-P4 which has 32MB of PSRAM. I'm trying to figure out how to do this now.
hathym•12m ago
I tested with

  import needle

  @needle.tool
  def add(a: int, b: int):
      "Add two numbers."
      return a + b

  agent = needle.Needle(tools=[add])
  print(agent.run("calculate 1 + 1?")["reasoning"])

python main.py No calculator or math tool available.

conclusion: completly useless

HenryNdubuaku•3m ago
Try the following tool description: "Calculate the sum of two numbers. Use for any arithmetic or math question." instead of "Add two numbers." Let me know how it goes, thanks!
HenryNdubuaku•2m ago
It does better with clearer tool description, but we are taking note of these complaints for future improvements.
profsummergig•12m ago
Could someone please share how such open source micro-LLMs might have been created?

Do the creators take something like DeepSeek, and then delete most of the neurons to whittle down the size?

forsalebypwner•3m ago
Any instructions available for running this on an ESP32-S3 or P4 like the site says?