NeuDecide

A tiny voice-action model. Audio and a list of tools in, a tool call out. No transcript in between.

GitHub · PyPI · HF Space · arXiv (coming soon)

NeuDecide converts speech directly into function calls. It's 43 MB, can run on a single thread via ONNX Runtime, and needs no GPU or internet connection once downloaded. Tools are passed in as JSON schemas at inference time, so you change what the model can do by changing the JSON, not by retraining.

"clean the bathroom"  +  [cleanRoom, goToBase, getBattery]   →   [{"name": "cleanRoom", "arguments": {"room": "bathroom"}}]

Installation

pip install neudecide

Requires Python 3.10 – 3.13. The model weights are downloaded from the Hugging Face Hub on first use and cached after that.

Quickstart

This example turns a recorded voice command into a call for a robot vacuum. Save a WAV recording of yourself saying something like "clean the bathroom" as command.wav, then run:

from neudecide import NeuDecide

TOOLS = [
    {
        "name": "cleanRoom",
        "description": "Vacuum-cleans one room.",
        "parameters": {
            "type": "object",
            "properties": {
                "room": {
                    "type": "string",
                    "enum": [
                        "living room",
                        "bathroom",
                        "kitchen",
                        "bedroom",
                    ],
                },
            },
            "required": ["room"],
        },
    },
    {
        "name": "goToBase",
        "description": "Sends the vacuum back to its charging base.",
        "parameters": {
            "type": "object",
            "properties": {},
        },
    },
    {
        "name": "getBattery",
        "description": "Reports the vacuum's battery level.",
        "parameters": {
            "type": "object",
            "properties": {},
        },
    },
]


def main():
    model = NeuDecide.from_pretrained()
    calls = model.generate("command.wav", TOOLS)
    print(calls)


if __name__ == "__main__":
    main()

Output:

[{'name': 'cleanRoom', 'arguments': {'room': 'bathroom'}}]

generate returns a list of {"name", "arguments"} dicts, or [] when no tool applies. If the answer reaches the 128-token output limit, you get the calls completed before it, with a warning.

A command-line version is in examples/basic_example.py. From a clone of the GitHub repo, python examples/basic_example.py runs it on examples/command.wav with the tools in examples/tools.json; pass --audio and --tools to use your own.

Usage

Audio input

audio can be a path to a PCM WAV file or a NumPy array. Arrays may be mono (samples,) or multi-channel (samples, channels); channels are averaged to mono. Integer arrays, such as the int16 samples scipy.io.wavfile.read returns, are scaled to [-1, 1] automatically; float arrays should already be in [-1, 1]. Audio is resampled to 16 kHz automatically, so pass sample_rate= if your array is at a different rate:

calls = model.generate("command.wav", TOOLS)                     # WAV file
calls = model.generate(waveform, TOOLS, sample_rate=44100)       # NumPy array

Only WAV is read natively. For other formats (MP3, FLAC, OGG), load the audio yourself and pass the array. Audio longer than 30 seconds is truncated.

Tool definitions

Each tool has a name, a description, and parameters as a JSON Schema object. You can pass the list directly or as a JSON string. The model only knows what you tell it about each tool, so clear names and descriptions do most of the work. When an argument has a fixed set of values, like the rooms above, list them with enum.

How it works

NeuDecide is a pre-trained streaming English speech encoder joined to a compact tool-calling encoder–decoder, initialised from Needle, and trained end to end as one system. Inference runs three ONNX graphs:

Tools are serialised exactly as Python's json.dumps writes them by default, matching how the model was trained.

Results

We compared NeuDecide with five speech-recognition cascades (Parakeet 110M and 660M feeding Needle or FunctionGemma, and Whistle feeding Needle 3) and with Voxtral Mini 3B, an end-to-end speech model. Each system chooses from 10 tools. Some requests need only the right tool; the rest also need its arguments filled, and exact match counts a call as right only if the tool and every argument match. The results cover both kinds of request together, weighted by how many of each SLURP has, as in the plot. The table shows two of the cascades alongside Voxtral Mini 3B; a cascade's size counts its ASR and decision model together.

On SLURP, NeuDecide beats every other system on both metrics. With 10 tools, it gets more than five times as many commands exactly right as the best cascade or Voxtral Mini 3B.

Performance

Measured with the q4 export:

Peak RAM ranged from 146 MB to 174 MB across these devices; it depends on the runtime and workload.

Limitations

• It can fire on noise. Given 30 s of low-level noise, it still produced a call. There is no calibrated confidence score yet, so put a gate in front: voice-activity detection, or an explicit "no action" tool.
• Keep tool lists short. We recommend at most 10 tools. Longer lists also cost more compute than longer audio, and lists over 1,536 tokens are truncated with a warning.
• English only.
• Length limits. Inputs are capped at 30 s of audio, and outputs are capped at 128 tokens.
• Free-form arguments are harder. On SNIPS, where arguments are often open-ended names such as artists and playlists, transcript-based cascades still fill arguments more accurately. Use enum wherever an argument has a fixed set of values.

Test it on your own tools and your users' voices before deploying. NeuDecide works best next to a larger model: let it handle the fast, frequent, bounded decisions, and route anything it can't place to a bigger model or a person.

Acknowledgements

• https://github.com/cactus-compute/needle
• https://huggingface.co/nvidia/stt_en_fastconformer_hybrid_medium_streaming_80ms

License

Apache 2.0. See LICENSE.