Build AI apps with Claude Code and NeuroBrix — no PyTorch glue code

You want AI inside your application: transcribe a meeting, summarise a note, generate an image, read a text aloud. Today that usually means PyTorch, a model library, one pipeline per model with its own pre- and post-processing, a CUDA build that matches your driver, and a layer of glue code between all of it. Every new model is a new integration. Every new GPU is a new compatibility table.

Hand that job to a coding agent and it spends its effort exactly there: on the glue.

NeuroBrix takes the glue away. It is an inference engine that runs 49 models in 9 families (language, code, vision-language, omni, speech recognition, speech understanding, text-to-speech, image, video, upscaling) from one container format and one command. And because the surface is that small, it is the kind of foundation a coding agent like Claude Code can build on quickly and correctly.

pip install neurobrix

Linux, Windows and macOS. NVIDIA, AMD, Intel and Apple GPUs. No PyTorch required.

One surface for every model

The application surface of NeuroBrix today is its command line, and it is the same for every family:

neurobrix import openai/whisper-large-v3-turbo --accept-license
neurobrix run --model whisper-large-v3-turbo --audio meeting.wav --output transcript.txt

neurobrix run --model TinyLlama-1.1B-Chat-v1.0 --prompt "Summarize: ..." --max-tokens 96 --output summary.txt
neurobrix run --model Kokoro-82M --prompt "Your order is ready." --output voice.wav
neurobrix run --model Sana_1600M_1024px_MultiLing --prompt "a glass cube on a circuit board" --output cube.png

One verb to run, one flag for the model, the inputs that family needs, and a file that comes out. The family is read from the model's container, so there is no pipeline class to pick, no processor to load, no device to place by hand: Prism, the engine's planner, reads your hardware and decides the placement. The commands that report state (import, list, info, inspect, doctor, hub) also speak JSON with --json, for programs rather than people.

For an agent, this is the important part. It does not need to learn N model APIs. It learns one command, once, and the knowledge transfers to every model in the catalogue — and to the models added in the next release.

The experiment: give Claude Code the repository

We tried it. We opened Claude Code in an empty folder on an Apple M4 Pro, with nothing but the public repository and PyPI, and gave it this prompt:

Build a small command-line app, "dictate", that turns a voice recording into a transcript and a short summary.
Use NeuroBrix (pip install neurobrix; https://github.com/NeuroBrix/neurobrix) as the only inference engine: no PyTorch,
no model-specific pipeline code. Speech recognition with whisper-large-v3-turbo, the summary with TinyLlama-1.1B-Chat.
Output: a Markdown note next to the recording.

It read the README and neurobrix --help, and wrote this. The whole application:

#!/usr/bin/env python3
"""dictate — voice recording -> transcript -> short summary, with NeuroBrix as the inference engine.

    python dictate.py meeting.wav            # writes meeting.md
"""
import subprocess, sys, tempfile
from pathlib import Path

STT_MODEL = "whisper-large-v3-turbo"
LLM_MODEL = "TinyLlama-1.1B-Chat-v1.0"


def neurobrix(*args: str) -> str:
    """Run one `neurobrix run` and return the text it wrote to --output."""
    with tempfile.TemporaryDirectory() as tmp:
        out = Path(tmp) / "out.txt"
        subprocess.run(["neurobrix", "run", *args, "--output", str(out)], check=True,
                       stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
        return out.read_text().strip()


def main(audio: Path) -> Path:
    transcript = neurobrix("--model", STT_MODEL, "--audio", str(audio))
    summary = neurobrix("--model", LLM_MODEL, "--max-tokens", "96",
                        "--prompt", f"Summarize this in two sentences:\n\n{transcript}")
    note = audio.with_suffix(".md")
    note.write_text(f"# {audio.stem}\n\n## Summary\n\n{summary}\n\n## Transcript\n\n{transcript}\n")
    return note


if __name__ == "__main__":
    print(main(Path(sys.argv[1])))

And the one-time setup:

pip install neurobrix
[ "$(uname)" = Darwin ] && python -m nbxtensor install-metal   # Triton for Apple GPUs
neurobrix import openai/whisper-large-v3-turbo --accept-license
neurobrix import TinyLlama/TinyLlama-1.1B-Chat-v1.0 --accept-license

From the empty folder to a working note took under two minutes, most of it the setup. 34 lines, two models from two different families, one helper function. Running it:

$ python dictate.py memo.wav
memo.md

## Transcript

going along slushy country roads and speaking to damp audiences in draughty schoolrooms day after day
for a fortnight he'll have to put in an appearance at some place of worship on sunday morning and he
can come to us immediately afterwards

The transcript is exact. The summary comes from a 1.1-billion-parameter model, so it is rough. That is the point we want to make next.

Changing a model is changing a string

Want a better summary? Change LLM_MODEL to a larger language model from the catalogue — Qwen3, DeepSeek-Coder-V2-Lite, a vision-language model if you want to send images — and nothing else in the program changes. Want the note read aloud? One more call with a text-to-speech model. Want a cover image for it? One more call with an image model. Same verb, same flags, same output convention.

That is what "no glue code" means in practice. With a framework-first stack, each of those changes is a new library, a new pipeline, a new set of preprocessing rules, sometimes a new version of PyTorch. With NeuroBrix, the engine absorbs the difference, because the difference lives in the model's container, not in your code.

Why an agent finds this easier

We are not claiming magic. We are claiming a smaller surface, and agents are good at small surfaces:

• One API to learn instead of N. An agent writing against PyTorch and a model library has to get each model's loader, processor, dtype, device placement and output format right. With NeuroBrix it gets neurobrix run right once.
• No environment puzzle. No CUDA toolkit to match to a driver, no PyTorch wheel to pick per platform. The light install is 1.48 GB (6.82 GB with PyTorch), and neurobrix doctor tells the agent exactly what is missing and the command that installs it.
• The same path on every machine. Linux, Windows and macOS; NVIDIA, AMD, Intel and Apple GPUs. The code the agent writes on one runs on the others.
• Readable, honest output. Every run prints which engine ran and why, the placement Prism chose, and whether kernel settings came from a certificate. When something goes wrong, the agent can read what happened instead of guessing.
• Validated surface. Every release runs all 49 models on both engines through this exact entry point, outputs compared byte for byte with judged outputs. The command the agent calls is the command we test.

Keeping a model warm

A command per call reloads the weights each time, which is fine for a note and wasteful for a chat. neurobrix serve --model M keeps a model's weights in memory and answers requests; neurobrix chat talks to it. A documented Python API and a local server with a JSON interface for every command are on the roadmap, and they will keep this same shape: one entry point, any model.

The way we build it

NeuroBrix is one engine with zero per-model code. Every model ships as a .nbx container (graph and weights); adding a model means adding a container, not writing code, so the catalogue grows with every release. Prism plans memory and placement from a file of facts about your hardware. The Triton engine runs on nbxtensor, our own tensor library, with no PyTorch; an optional PyTorch engine runs the same containers. Kernel settings are certified once per GPU class against a float64 oracle instead of being autotuned on your machine.

The ecosystem

• NeuroBrix Engine — pip install neurobrix
• nbxtensor — the tensor library without PyTorch
• Model Hub — neurobrix.es/models, more models every release
• triton-ext — our Triton build for Apple GPUs
• Studio — a desktop application for Linux, Windows and macOS, in development, for people who will never open a terminal

Next on the roadmap: local agents built on the engine, a local server for applications, training in nbxtensor, nbxtensor 2.0 in Rust, and .nbx as an open model standard.

Try it with your agent

pip install neurobrix
neurobrix doctor

Then open Claude Code (or your coding agent) in an empty folder, point it at github.com/NeuroBrix/neurobrix, and describe the app you want. Tell us what it built.

• Star the repository — it is how other developers find it.
• Open an issue when something breaks, or to request a model.

Apache 2.0.

Hocine Benkelaya, NeuroBrix