Show HN: Cactus Needle 3 — Tiny Automation Models Rivaling DeepSeek V4 Flash

Cactus has unveiled Needle 3, a specialized foundation model designed specifically for the constraints of tiny hardware. Ranging from 8MB to 29MB, this model is engineered for mobile devices, wearables, robotics, smart home systems, automotive interfaces, and microcontrollers.

The core innovation is the "Intelligence Ladder": a single binary where every depth from 2 to 20 layers functions as its own standalone model.

---

🚀 Core Capabilities

Needle 3 prioritizes automation over general-purpose chatting. By trading off conversational breadth, it outperforms models 10x its size in mobile tool calling and matches models 2-3x larger in data extraction.

• Tool Calling: Needle 3 analyzes available functions and populates arguments precisely from user input.
  • Multi-step: Handles multiple requests in the correct sequence.
  • Precision: Returns an empty list rather than hallucinating/guessing when no tool fits.
• Structured Extraction: Converts unstructured, "messy" text into typed fields (e.g., turning a raw email into a JSON booking or invoice).
• Text Embedding: Generates local vectors for sentences, enabling on-device semantic search, request routing, and alert deduplication.

---

🛠️ Real-World Applications

---

🧬 Technical Architecture: The Intelligence Ladder

Needle 3 utilizes a Simple Attention Network (SAN). Each layer is a sub-network with monotonically increasing capacity.

*When fine-tuned on downstream tasks for one epoch.

📊 Specifications & Performance

• Model Size: 29-121M parameters (CQ2 quantization).
• Training: 360B tokens of proprietary structured data.
• Speed (Raspberry Pi 5):
  • Decode: $400 \text{ to } 4,000 \text{ tokens/s}$
  • Prefill: $1,000 \text{ to } 10,000 \text{ tokens/s}$

🧮 Mathematical Foundations

The architecture is highly efficient, consuming over 2x fewer MFLOPs per token than equivalent transformers.

Lane Read/Write & Fusion:

• Lane read: $u = \sum_n \sigma(a \phi_n^T \hat{x} + b) X_n, \hat{x} = \text{rms}(\text{lanes})$
• Engram fusion: $x \leftarrow x + \sigma(\langle \hat{x}, \hat{k} \rangle / \sqrt{d}) \cdot v$
• Lane write: $X' = P X + 2\sigma(h) \otimes y, P = \text{Sinkhorn}(A)$

FFN & Attention:

• Monarch Hadamard FFN: $y = D_4 M_3 D_3 M_2 \text{silu}(D_2 c(x) M_1 D_1 x + b)$
• Attention: GQA, RoPE, and QK-norm with a 1024 window (global at layers 4, 9, 14, 19).

---

📈 Benchmarks & Validation

Key Finding: Needle 3 beats models 10x its size on mobile tool calls and matches models 2-3x its size on extraction.

Evaluation Suites:

• Mobile Actions: Android intents (961 rows).
• DroidCall: Sequential phone requests (200 rows).
• BFCL v4: Berkeley function calling (3,641 rows).
• DSTC8: Dialogue slot filling (1,813 turns).
• SNIPS: Gold slot filling and 7-way schema selection.

---

💻 Developer Integration

The model is distributed as a CQ2-bit binary via Hugging Face. Integration is handled through a simple Python API where docstrings serve as the tool descriptions.

import needle

# Define a tool using a decorator
@needle.tool
def get_weather(city: str):
    """Get the current weather for a city."""
    return {
        "city": city, 
        "temp_c": 27, 
        "sky": "clear"
    }

# Initialize the agent with the toolset
agent = needle.Needle(tools=[get_weather])

# Execute a request
print(agent.run("what's it like in Lagos right now?"))

The Workflow:

1. Needle reads the tool signature (types) and docstring (description).
2. The model selects the correct tool and fills the arguments.
3. agent.run() executes the function and feeds the result back.
4. The final response is returned with the results attached.