# Needle 3

> Cactus Compute's September 2026 on-device automation model: one 8–29 MB file that does tool calls, structured extraction and text embeddings, from phones down to microcontrollers.

- Maker: Cactus Compute
- Line: Needle
- Canonical page: https://ai-tldr.dev/models/needle-3/
- Updated: 2026-09-21

## In short

Needle 3 is Cactus Compute's automation foundation model, published on September 17, 2026 under Apache-2.0.

## Facts

| Fact | Value | Source |
| --- | --- | --- |
| Licence | Apache-2.0 · open weights | [1] |
| Released | 17 September 2026 | [2] |
| Parameters | 121M at 20 layers; every depth from 2 to 20 layers ships as a deployable subnetwork (29M at 4 layers) | [1] |

## Sources

1. [Needle 3 model card (weights)](https://huggingface.co/Cactus-Compute/needle3)
2. [Needle 3 release page](https://cactuscompute.com/needle)

## Overview

Needle 3 is Cactus Compute's automation foundation model, published on September 17, 2026 under Apache-2.0. It gives up general chat capacity on purpose and keeps three jobs that it runs entirely on the device: picking and filling tool calls from the functions an app exposes, pulling typed fields out of messy text against a declared shape, and returning a sentence embedding so an app can search, match and route locally.

The whole model is a single file of 8 to 29 MB. Cactus calls the architecture a Laddered Simple Attention Network: a Monarch Hadamard MLP replaces the FFN, attention is GQA with causal conv taps, and an engram n-gram memory holds most of the parameters, so the 121M model does the arithmetic of a 50M one. It is trained so that every depth from 2 to 20 layers is itself a deployable model, and the weights are compressed to CQ2-bit with Cactus Quants at 2.125 bits per weight.

Outputs are constrained rather than hoped for: a byte-level grammar compiled from the caller's schemas gates every token, so extraction output parses by construction, and each response carries a calibrated confidence score from a learned head. A request no tool covers returns an empty list instead of a guess. The repo ships the 20-layer needle3.cact, the needle3.safetensors checkpoint for fine-tuning, and a sub-1 MB engine per platform covering macOS, Linux (x86_64, ARM64, ARMv7, RISC-V64, MIPSEL), Windows, Android, iOS, tvOS, watchOS and WebAssembly.

## Benchmarks

- Mobile Actions (exact call, 961 rows): 86% ([source](https://huggingface.co/Cactus-Compute/needle3))
- BFCL v4 (AST match, 3,641 rows): 50.2% ([source](https://huggingface.co/Cactus-Compute/needle3))
- DroidCall (exact calls in order, 200 rows): 47% ([source](https://huggingface.co/Cactus-Compute/needle3))
- DSTC8 (field F1, 1,813 turns): 40.7% ([source](https://huggingface.co/Cactus-Compute/needle3))
- SNIPS gold (field F1, 700 rows): 30.2% ([source](https://huggingface.co/Cactus-Compute/needle3))
- SNIPS 7-way (field F1, 700 rows): 24.7% ([source](https://huggingface.co/Cactus-Compute/needle3))

## Strengths

- 86.0% exact-call accuracy on Mobile Actions at 121M parameters, against 88.4% for the cloud-hosted DeepSeek V4 Flash
- Ships as one 8–29 MB file with a sub-1 MB engine per platform, down to RISC-V and MIPSEL microcontrollers
- Byte-level decode grammar compiled from the caller's schemas, so structured output parses by construction
- Calibrated per-response confidence score, and an empty call list rather than a guess when no tool fits
- Ladder training: any depth from 2 to 20 layers is deployable, and LoRA fine-tuning on DroidCall lifts every subnetwork by 18 to 36 points

## Best for

- Reach for it when an app has to turn speech or text into tool calls on a phone, wearable or smart-home hub with no network round trip.
- Reach for it when you need typed JSON out of messy text — an invoice, a booking, a notification — and the output must parse every time.
- Reach for it when local search or routing needs embeddings from the same binary that already does the tool calling.
- Reach for it when one product's tool set is narrow enough to fine-tune a 2–8 layer subnetwork onto very small hardware.

## Needle versions

- Needle 3 (17 September 2026): Laddered SAN at 121M; adds text embeddings alongside tool calling and extraction, and makes every depth from 2 to 20 layers deployable. — this page
- Needle 2 (10 August 2026): 45M-parameter tool-calling and extraction model; scores 63.5% on Mobile Actions in Cactus Compute's Needle 3 comparison.

## FAQ

### How big is Needle 3 and what hardware does it run on?

Needle 3 ships as a single file of 8 to 29 MB, depending on how many of its 2-to-20 layers you deploy, with a separate engine under 1 MB per platform. Cactus publishes engines for macOS ARM64, Linux (x86_64, ARM64, ARMv7, RISC-V64, MIPSEL), Windows (x86_64, ARM64), Android, iOS, tvOS, watchOS and WebAssembly.

### What can Needle 3 actually do?

Three things, all on the device: it picks tool calls from the functions your app exposes and fills their arguments, it extracts typed fields from messy text against a schema you declare, and it returns text embeddings for local search and routing. It deliberately has no general chat capability.

### How does Needle 3 score against larger models?

On Cactus Compute's published benchmarks, the 20-layer 121M Needle 3 reaches 86.0% exact-call accuracy on Mobile Actions against 88.4% for the cloud-hosted DeepSeek V4 Flash, 82.4% for LFM2.5 1.2B and 57.6% for Apple FM. On BFCL v4 it scores 50.2% against 62.0% for LFM2.5 1.2B, and on DSTC8 field F1 it scores 40.7%.

### Is Needle 3 open weights?

Yes. The needle3.cact binary and the needle3.safetensors fine-tuning checkpoint are published on Hugging Face under Apache-2.0, and the Python package installs with pip install cactus-needle.

## Links

- [Needle 3 model card (weights)](https://huggingface.co/Cactus-Compute/needle3)
- [Needle 3 release page](https://cactuscompute.com/needle)
- [cactus-compute/needle on GitHub](https://github.com/cactus-compute/needle)
- [cactus-needle on PyPI](https://pypi.org/project/cactus-needle/)

Source: AI/TLDR LLM registry, https://ai-tldr.dev/models/needle-3/