\

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

291 points - yesterday at 5:22 PM


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!

Source
  • nater5000

    yesterday at 9:49 PM

    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

        yesterday at 9:56 PM

        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.

          • anon373839

            today at 4:55 AM

            It seems to me that the model struggles to have enough general intelligence, knowledge, or reasoning capacity for arbitrary prompted tool calling. At this size, not surprising.

            I am VERY interested in seeing how it could perform with some fine-tuning for a specific family of tools/tasks. That would be a great addition to the demo.

            • fwipsy

              today at 12:41 AM

              14mb? More like sub-$20 devices.

                • TomatoCo

                  today at 12:46 AM

                  Most pi pico's come with 16mb of flash. I wonder what kind of performance that can eek out.

                    • SequoiaHope

                      today at 2:02 AM

                      Well running from QSPI flash (even the internal memory versions use SPI internally) so any inference would be very slow streaming from that compared to RAM. The featured article says: “With a peak session RAM around 28MB, Needle runs on newer microcontrollers like ESP32-S3.” So I don’t see this doing anything useful on a Pico. The Pico 2 (RP2350) for example has 520k of RAM.

                        • Rohansi

                          today at 3:15 AM

                          An ESP32 has the same amount of SRAM as the Pi Pico. You can hook up PSRAM to the Pi Pico just like ESP32 to get 16MB more RAM.

          • silentbob7

            today at 5:30 AM

            I'm quite impressed by the results of the web demo, especially given its size and the precision with which it uses the three available tools (tested with German commands). I could imagine that this LLM would fit well into a setup with multiple micro-sized LLMs for different purposes; so 14 MB for precise tool invocation is a reasonable memory footprint when a number of other local models are running (e.g. STT, TTS + language models).

        • rcarmo

          today at 6:44 AM

          Nice. I used Needle as a router in https://rcarmo.github.io/projects/memento/, need to take a look at this

          • dbeardsl

            today at 12:50 AM

            My first query:

            > Make it a little warmer in here.

            The reply:

            > "name": "set_thermostat", > "arguments": { > "temperature": 65, > "mode": "cool", > ... > "reasoning": "'warmer' implies need for cooling; set_thermostat with temperature 65 (typical warmth) and mode 'cool'.",

            Maybe I'm doing it wrong?

              • ocihangir

                today at 6:42 AM

                Tested your example, the confidence is 0. In smart home context, I can think of an application where the low confidence answers can be forwarded to cloud, whereas the vast majority generic queries solved locally, if the confidence is reliable enough. The response is quite fast by the way.

                • dannyw

                  today at 1:13 AM

                  It's not a conversational model. It's meant as a local tool calling model.

                    • derangedHorse

                      today at 1:35 AM

                      Yes, I think OP understands that. What he and many others in this thread are trying to understand is what makes this model useful.

                        • ehnto

                          today at 2:47 AM

                          Turning a voice command into a tool call should be self evidently useful, being able to do that on a small embedded device is the novelty here. In this theoretical example, the thermostat is hosting the model on device and would use no external services.

                            • tomrod

                              today at 2:51 AM

                              I confused by the dispatch model. Tool calls typically need some reasonability to be deterministic and, more importantly, predictable in response (o/w GIGO). Why would the thermostat need to interpret a voice command that the node capturing the voice command would not interpret instead?

                                • ehnto

                                  today at 4:14 AM

                                  The node capturing the voice command could be the thermostat. From my understanding they are targeting very small devices.

                                  So that could be a master home automation node, but why not also a single purpose device? I can think of more bad examples than I can good ones, but maybe I am doing some soldering and I need my soldering iron turned up a bit; my hands are full, so doing that by voice would be useful enough. Something I would never link up to a big AI model or home automation network, but could be useful to control by voice.

                                  If it's something that can be burnt directly into a chip and shipped with the products for cheap, maybe that's a more pragmatic way to get AI into small devices (see taalas for a much bigger model doing that, althoug not yet cheap).

                                    • tomrod

                                      today at 4:28 AM

                                      Oh I agree that's not unreasonable. I wonder about the harnessing heft required to make it feasible though. If I say I'd like it a bit warmer, a tool can deterministically bump a few degrees while an LLM might bump it 10C. So do we limit the tool's range?

                      • today at 1:18 AM

                    • owebmaster

                      today at 3:04 AM

                      Try asking it to set the thermostat to a value. It's a very small model, there's not much reasoning capability

                  • Tiberium

                    yesterday at 9:06 PM

                    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.

                      • yoavm

                        yesterday at 9:23 PM

                        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

                            yesterday at 9:34 PM

                            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

                                yesterday at 9:41 PM

                                > "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

                                    yesterday at 9:52 PM

                                    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

                                  yesterday at 9:57 PM

                                  Thanks, noted!

                              • planb

                                today at 5:56 AM

                                This is extremely impressive if it works. But on the other hand, if the number of cases where it works as expected is lower than what we could catch with a (old-Siri-style) heuristics based approach, and the rest fails in unpredictable ways, I'd prefer the dumb old "I did not understand that" response.

                                • curious_cat_163

                                  today at 1:20 AM

                                  I think the test above is about tool calling... That's how I read it. The issue here is known as "out of distribution detection" in the old-timey classification world.

                                  I am not sure how a micro model will fundamentally solve it. Would love to understand what dannyw and team did there?

                                    • derangedHorse

                                      today at 1:41 AM

                                      How did you draw an association between dannyw and Cactus? There are no 'Danny's on the list of GH contributors nor is there one named in the paper. Just curious.

                              • petu

                                yesterday at 9:38 PM

                                "confidence": 0, so I guess you could threshold it

                                  • justoneletter

                                    today at 4:40 AM

                                    Only if the confidences are calibrated, and they probably aren't. Any idea how the confidence is derived?

                                • jszymborski

                                  yesterday at 9:14 PM

                                  no, this is the appropriate response to hearing the words "HN" :P

                                  • plingbang

                                    yesterday at 11:02 PM

                                    I've got an identical output with the prompt "do not lock the door".

                                    • hmokiguess

                                      yesterday at 9:41 PM

                                      yeah I got the same, almost like its biased heavily towards that as the 0 ranking -- my prompt was just the word 'potato'

                                      • Schiendelman

                                        yesterday at 9:16 PM

                                        Was that the first message you sent it?

                                        • HenryNdubuaku

                                          yesterday at 9:48 PM

                                          This is exactly why the confidence feature was introduced, the model knows when its wrong, we could hide that part and return a placeholder "sorry I only do function calls", would that be better or you prefer to see everything?

                                          • nc55g3g

                                            today at 1:12 AM

                                            [dead]

                                        • arthuqa

                                          yesterday at 9:26 PM

                                          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

                                              yesterday at 9:39 PM

                                              Thanks, give it a splin!

                                          • profsummergig

                                            yesterday at 10:05 PM

                                            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?

                                              • anigbrowl

                                                today at 1:16 AM

                                                There's a Manning book on creating your own LLM from scratch which answers your question exactly. There's another book from the same publisher specifically about small language models for specialty purposes.

                                                • HenryNdubuaku

                                                  yesterday at 10:19 PM

                                                  Technically, you could do that, but we trained this one from the ground up!

                                                    • profsummergig

                                                      yesterday at 11:50 PM

                                                      That sounds like an enormously expensive exercise.

                                                        • salamo

                                                          today at 12:21 AM

                                                          As someone who's done something similar (https://blog.lukesalamone.com/posts/creating-tiny-semantic-s...) the expensive part wasn't the training itself but the data curation and evaluation post-training. For this, getting a reasonable distribution of tool calls when the tool call can be anything isn't easy.

                                                          Once you have that, the model is small enough batch sizes are probably enormous and training can probably be done on a consumer-grade GPU in a week or less. Or even faster on a bigger GPU.

                                                          • ronsor

                                                            today at 12:17 AM

                                                            At <50M parameters, training costs are completely trivial. You'll spend a lot more on your rent this month.

                                                            • kadoban

                                                              today at 1:07 AM

                                                              Training scales pretty badly, so smaller models like this are really not that bad in terms of cost.

                                                              • genxy

                                                                today at 12:58 AM

                                                                You can train a model of this size on your laptop in a day.

                                                        • hgoel

                                                          yesterday at 11:32 PM

                                                          Another option for something this small and narrowly specialized could be to get traditional LLMs to synthesize the training data. Model collapse is probably less of an issue at this size relative to terabyte sized models.

                                                      • hathym

                                                        yesterday at 10:04 PM

                                                        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

                                                            yesterday at 10:14 PM

                                                            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

                                                                yesterday at 10:14 PM

                                                                It does better with clearer tool description, but we are taking note of these complaints for future improvements.

                                                                • hathym

                                                                  yesterday at 10:21 PM

                                                                  works better that way, thanks :)

                                                                    • hathym

                                                                      yesterday at 10:23 PM

                                                                      but still struggle when changing the quesion:

                                                                        import needle
                                                                      
                                                                        @needle.tool
                                                                        def add(a: int, b: int):
                                                                            "Calculate the sum of two numbers. Use for any arithmetic or math question."
                                                                            return a + b
                                                                      
                                                                        agent = needle.Needle(tools=[add])
                                                                        print(agent.run("what is 5 + 7?")["reasoning"])
                                                                      
                                                                      
                                                                      >> No calculator or math tool available. Cannot compute numbers.

                                                                        • HenryNdubuaku

                                                                          yesterday at 10:33 PM

                                                                          Ah, another failure point on our end! So a simple "5 + 7" and "add 5 and 7" works. But to handle ambiguity, the python package ships pipelines to synthesize augmentations and fine-tune on your samples for robustness. Just run "needle playground" and use the UI. Apologies.

                                                                      • HenryNdubuaku

                                                                        yesterday at 10:21 PM

                                                                        Thanks, we shall improve this for the next release.

                                                            • redrix

                                                              yesterday at 9:51 PM

                                                              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.

                                                                • dalemhurley

                                                                  yesterday at 10:49 PM

                                                                  agreed, this is where we have the biggest opportunity for innovation.

                                                                  • HenryNdubuaku

                                                                    yesterday at 9:53 PM

                                                                    thanks!

                                                                • kooi

                                                                  today at 4:12 AM

                                                                  Its pretty significant you've got this working locally in wasm. Very cool.

                                                                  Re: robotics: I'm unsure how this could be helpful.

                                                                  It fails a pretty simple navigation prompt.

                                                                  X0: (0.0, 0.0). Object bounding box: [1.0, 1.0, 2.0, 2.0]. navigate to (3.0,3.0)

                                                                  I changed it to "call path planner to navigate: a_star(x0, xf, obs)"

                                                                  Another fail.

                                                                  My intuition tells me micro llms will/are important for robotics. I just can't grok it. Can someone without control theory experience give me a good example?

                                                                  Probably at the planning level of the navigation stack. That's where I see reasoning being helpful. Lower than that...idk

                                                                  Give me an example of a robotics prompt that seems useful and I'll give you an example why we don't need LLMs to be a tracking controller, etc.

                                                                  • tolugenius

                                                                    yesterday at 8:56 PM

                                                                    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

                                                                        yesterday at 9:04 PM

                                                                        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.

                                                                          • rshemet

                                                                            today at 2:39 AM

                                                                            Roman from Cactus here -

                                                                            yes you're right, there's only so much a 14MB model can do.

                                                                            Needle excels at in-conext inference, with tightly defined environments. In our experience:

                                                                            accurate descriptions + narrow tool scope = success

                                                                    • hgoel

                                                                      yesterday at 10:02 PM

                                                                      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.

                                                                        • HenryNdubuaku

                                                                          yesterday at 10:28 PM

                                                                          That demo was Needle 1 indeed and we are creating the guide for ESP32 now as we speak.

                                                                          • forsalebypwner

                                                                            yesterday at 10:12 PM

                                                                            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.

                                                                        • prmoustache

                                                                          today at 5:26 AM

                                                                          How many languages does it supports in such a small size?

                                                                            • silentbob7

                                                                              today at 6:06 AM

                                                                              Tested with german and this kinda works, but confidence suffers.

                                                                          • pylotlight

                                                                            today at 2:08 AM

                                                                            What about use case for replacing regex? I.e "random formatted title.extension" - extract the title or some tag or something for more dynamic string manipulation for pulling structured data out of strings efficiently and more simply than regex provides?

                                                                            • mmastrac

                                                                              yesterday at 11:52 PM

                                                                              Congrats on this release. The WASM implementation is really cool. This is a surprisingly good fit for a lot of cases, and I totally want to try turning this into a helper assistant for an application.

                                                                              Please, though, take a pass at humanizing the text on the page. It's Clauded up all over and makes it hard to read.

                                                                              • dangoodmanUT

                                                                                today at 12:31 AM

                                                                                > turn on the tv

                                                                                { "function_calls": [ { "name": "lock_door", "arguments": { "door": "tv" } } ], "confidence": 0.0158 }

                                                                                Very interesting, seems confidence is 0 when tool calls are right?

                                                                                  • pylotlight

                                                                                    today at 2:06 AM

                                                                                    You may want to reword that.. what do you think 0 confidence means... ?

                                                                                • skavi

                                                                                  yesterday at 10:31 PM

                                                                                  I wonder if there's any way to get this to plan out a dag of tool calls? i.e. use the results from earlier calls as the parameters to later ones? I tried introducing a stack based system, but gave up pretty quickly.

                                                                                    • HenryNdubuaku

                                                                                      yesterday at 10:34 PM

                                                                                      Yes, though for better results in production, after creating your tool json, use the provided data synthesis and fine-tuning pipeline. It tunes on on your mac.

                                                                                  • minimaltom

                                                                                    yesterday at 9:40 PM

                                                                                    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

                                                                                        yesterday at 9:44 PM

                                                                                        Yes, we ablated Engrams rigorously and found that it returned world knowledge like FFN without without compute expenditure.

                                                                                          • minimaltom

                                                                                            yesterday at 9:55 PM

                                                                                            What about mHC? I'm surprised it helped with such a small compute budget.

                                                                                              • HenryNdubuaku

                                                                                                yesterday at 10:26 PM

                                                                                                [flagged]

                                                                                    • dofm

                                                                                      yesterday at 9:30 PM

                                                                                      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

                                                                                        • nater5000

                                                                                          yesterday at 9:41 PM

                                                                                          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.

                                                                                            • silentbob7

                                                                                              today at 5:52 AM

                                                                                              The wyoming protocoll seems to be the path for home assistant audio, so you need STT (wyoming-faster-whisper), TTS (wyoming-piper for wide language support) API endpoints and some Ollama or OpenAI API endpoint available for your home assistant server.

                                                                                              • dofm

                                                                                                yesterday at 9:55 PM

                                                                                                This is a very responsive answer, thank you so much. (I'd assumed maybe Whisper but the wake word "loop" detail there is illuminating.)

                                                                                            • HenryNdubuaku

                                                                                              yesterday at 9:40 PM

                                                                                              Users often stack a transcription model on top to get the voice prompt, then decode to actions. Think of Alexa and Siri.

                                                                                                • dofm

                                                                                                  yesterday at 9:59 PM

                                                                                                  Thank you.

                                                                                          • sroussey

                                                                                            yesterday at 10:49 PM

                                                                                            Looking forward to npm version of needle-rs supporting v2. I added needle support for tool use in my side project.

                                                                                              • HenryNdubuaku

                                                                                                yesterday at 11:34 PM

                                                                                                thanks, give the playground a go and let us know how to improve!

                                                                                                  • sroussey

                                                                                                    today at 12:03 AM

                                                                                                    I tried tweeking for structured extraction, but got issues with token budget. What is the context size?

                                                                                            • anr0

                                                                                              today at 3:46 AM

                                                                                              these micro LLMs could be a game changer for hearing aids

                                                                                              so many interesting lowfi hardware use cases

                                                                                              • snyp

                                                                                                today at 2:57 AM

                                                                                                This is so cool! Congrats to the team!

                                                                                                • tamperoff

                                                                                                  today at 2:26 AM

                                                                                                  Is there a prebuilt apk somewhere?

                                                                                                • forsalebypwner

                                                                                                  yesterday at 10:13 PM

                                                                                                  Any instructions available for running this on an ESP32-S3 or P4 like the site says?

                                                                                                    • rshemet

                                                                                                      yesterday at 10:48 PM

                                                                                                      Hey! Roman here from Cactus - yes, we're putting putting together a detailed guide for ESP32.

                                                                                                      In the meantime, if you have enough RAM for the current model (≈28MB), our repo will get you up & running:

                                                                                                      https://github.com/cactus-compute/needle

                                                                                                        • forsalebypwner

                                                                                                          today at 12:34 AM

                                                                                                          [dead]

                                                                                                  • ianseyler

                                                                                                    yesterday at 9:51 PM

                                                                                                    I’d be interested in attempting to run this in a network- enabled 32MiB RAM microVM.

                                                                                                      • HenryNdubuaku

                                                                                                        yesterday at 9:52 PM

                                                                                                        Thanks, how can we help?

                                                                                                    • yorwba

                                                                                                      yesterday at 10:32 PM

                                                                                                      "make it as dark as possible"

                                                                                                        {
                                                                                                          "function_calls": [
                                                                                                            {
                                                                                                              "name": "set_thermostat",
                                                                                                              "arguments": {
                                                                                                                "temperature": 72,
                                                                                                                "mode": "cool",
                                                                                                                "room": "living room"
                                                                                                              }
                                                                                                            }
                                                                                                          ],
                                                                                                          "reasoning": "'as dark as possible' -> set_thermostat to warm; 'dark' implies higher temperature; 'cool' mode for darkness.",
                                                                                                          "confidence": 0
                                                                                                        }
                                                                                                      
                                                                                                      ... maybe this counts as dark humor at least.

                                                                                                      Since it seems limited to matching a few templates and otherwise falling flat on its face, I wonder how 14MB of regexes would fare in its stead. Normally you wouldn't want to parse arbitrary natural language input with regex because of how tedious and brittle it would be, but for the tedium we have LLMs and this alternative isn't exactly robust either.

                                                                                                        • silentbob7

                                                                                                          today at 5:59 AM

                                                                                                          I also wonder how small a LLM trained on catching only subject (e.g. living room) and action (light on) from text input could be compared to needle - the json wrapping could be done afterwards using templates.

                                                                                                      • mickael-kerjean

                                                                                                        today at 12:35 AM

                                                                                                        Any plan to release on ollama?

                                                                                                        • written-beyond

                                                                                                          yesterday at 11:52 PM

                                                                                                          Great work! Keep it up

                                                                                                          • KennyBlanken

                                                                                                            today at 2:54 AM

                                                                                                            If you want Needle2 to rget lots of testing, become well known, etc - make a Home Assistant plugin.

                                                                                                              • rshemet

                                                                                                                today at 4:28 AM

                                                                                                                hey Kenny, Roman from Cactus here -

                                                                                                                could you say more? What kind of home assistant / what stack

                                                                                                            • peter_d_sherman

                                                                                                              today at 5:42 AM

                                                                                                              Utterly Fascinating!

                                                                                                              For the longest time, I conceptualized LLM's as Text Input -> Text Output transformers, then later as Text Input -> Video Output transformers. Later still I conceptualized them (if they were general purpose) as Any Format Input -> Any Format Output transformers...

                                                                                                              The idea of a smaller parameter model runable on smaller/slower/less complex hardware (computers with no GPU, slower CPU's, less memory, aka "Edge Devices") trained for Text Input -> JSON Output (used for tool calls, etc.) I could honestly not conceptualize before seeing the demo on the web page...

                                                                                                              But now that I've seen it and conceptualized it -- I'd have to say: "Yes, there's definitely a huge niche, a huge market for this, directly between the non-LLM driven tools and software and SaaS's of yesteryear, and the latest, cutting edge Frontier AI models of today!"

                                                                                                              So, I like Needle a lot!

                                                                                                              I like Needle a lot, and I love the idea of any tiny resource-thrifty LLM that can run on older hardware, that outputs only JSON!

                                                                                                              I can see a huge market for it!

                                                                                                              • platevoltage

                                                                                                                today at 1:09 AM

                                                                                                                This is very interesting! I'm going to spend some time with this. This is really the only class of LLM I'm interested in at all. I sincerely hope on-device takes over and everyone looses their asses on these data centers.

                                                                                                                • varispeed

                                                                                                                  yesterday at 9:32 PM

                                                                                                                  What is the difference between this and random sentence generator?

                                                                                                                    • HenryNdubuaku

                                                                                                                      yesterday at 9:41 PM

                                                                                                                      Random sentence is not a function call.

                                                                                                                      • actionfromafar

                                                                                                                        yesterday at 9:42 PM

                                                                                                                        Ask it to lock a door for instance. It seems to convert simple instructions to reasonable tool calls. Check its confidence score.

                                                                                                                    • yieldcrv

                                                                                                                      yesterday at 11:16 PM

                                                                                                                      what does the first L mean in LLM?

                                                                                                                        • janalsncm

                                                                                                                          today at 12:01 AM

                                                                                                                          Fwiw people have told me that GPT2 doesn’t qualify as an LLM at 550MB despite being one of the first LLMs.

                                                                                                                          So the practical answer to your question is: not much.

                                                                                                                          • rshemet

                                                                                                                            today at 2:45 AM

                                                                                                                            it stands for Lets-not-be-sarcastic :)

                                                                                                                        • liesliy

                                                                                                                          today at 6:00 AM

                                                                                                                          [flagged]

                                                                                                                          • TokenLat

                                                                                                                            today at 6:25 AM

                                                                                                                            [flagged]

                                                                                                                            • yesterday at 9:22 PM

                                                                                                                              • sroussey

                                                                                                                                today at 12:01 AM

                                                                                                                                [dead]

                                                                                                                                • grenli

                                                                                                                                  yesterday at 9:50 PM

                                                                                                                                  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

                                                                                                                                      yesterday at 10:01 PM

                                                                                                                                      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.